Color display library

Libraries, utilities, bootloaders...

Color display library

Postby Duhjoker » Mon Sep 05, 2016 9:38 am

I started trying to update the library file for my color LCD. Basically im just adding commands to the file from Summoner123's display.h file that has the tile map routines and a few other goodies. I commented out the color bits and stopped right at the part of the code where the GB color commands stop.

There are also some other commands included in the 7775 file that i didnt know if i needed so i left them commented out //.

What else might this need?

Code: Select all
#ifndef LCD_2000_7775_H
#define LCD_2000_7775_H

#include <Arduino.h>
#include <avr/pgmspace.h>
#include <SPI.h>

#include "settings.c"

//#if ARDUINO >= 100
 //#include "Arduino.h"
 //#include "Print.h"
//#else
 #include "WProgram.h"
//#endif
//#include "utility/Adafruit_GFX.h"

//#include <avr/pgmspace.h>

//colors
//#define WHITE 0
//#define BLACK 1
//#define INVERT 2 //// dont know what to put here since its 256k color
//#define GRAY 3

//for extended bitmap function :
#define NOROT 0
#define ROTCCW 1
#define ROT180 2
#define ROTCW 3
#define NOFLIP 0
#define FLIPH 1
#define FLIPV 2
#define FLIPVH 3

#if (DISPLAY_ROT == NO_ROT)||(DISPLAY_ROT == ROT180) //landscape mode
#define LCD_2000_7775_TFTWIDTH 220
#define LCD_2000_7775_TFTHEIGHT 176
#else //portrait mode
#define LCD_2000_7775_TFTWIDTH 176
#define LCD_2000_7775_TFTHEIGHT 220
#endif
#define LCD_2000_7775_TFTWIDTH 176
#define LCD_2000_7775_TFTHEIGHT 220


#define swap(a, b) { int8_t t = a; a = b; b = t; }

#define PCD8544_POWERDOWN 0x04
#define PCD8544_ENTRYMODE 0x02
#define PCD8544_EXTENDEDINSTRUCTION 0x01

#define PCD8544_DISPLAYBLANK 0x0
#define PCD8544_DISPLAYNORMAL 0x4
#define PCD8544_DISPLAYALLON 0x1
#define PCD8544_DISPLAYINVERTED 0x5

// H = 0
#define PCD8544_FUNCTIONSET 0x20
#define PCD8544_DISPLAYCONTROL 0x08
#define PCD8544_SETYADDR 0x40
#define PCD8544_SETXADDR 0x80
#define PCD8544_SETXADDR 0x80

// H = 1
#define PCD8544_SETTEMP 0x04
#define PCD8544_SETBIAS 0x10
#define PCD8544_SETVOP 0x80

extern uint8_t _displayBuffer[];




class LCD_2000_7775 : public Print {
   public:
      LCD_2000_7775(uint8_t cs,uint8_t wr ,uint8_t rs , uint8_t rest ,uint8_t pmw );
      LCD_2000_7775(uint8_t cs,uint8_t wr ,uint8_t rs , uint8_t rest );
      LCD_2000_7775(uint8_t cs,uint8_t wr ,uint8_t rs );
      //LCD_2000_7775(){};
      void write_spi(const uint8_t data);
      void begin(int8_t SCLK, int8_t DIN, int8_t DC, int8_t CS, int8_t RST);

      void command(uint8_t c);
      void data(uint8_t c);
      uint8_t* getBuffer();

      void setContrast(uint8_t val);
      void clear(void);
      void update();

      inline void drawPixel(int8_t x, int8_t y);
      inline uint8_t getPixel(int8_t x, int8_t y);

      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 drawLine(int8_t x0, int8_t y0, int8_t x1, int8_t y1);
      void drawFastVLine(int8_t x, int8_t y, int8_t h);
      void drawFastHLine(int8_t x, int8_t y, int8_t w);
      void drawRect(int8_t x, int8_t y, int8_t w, int8_t h);
      void fillRect(int8_t x, int8_t y, int8_t w, int8_t h);
      void fillScreen(uint8_t color);

      void drawCircle(int8_t x0, int8_t y0, int8_t r);
      void drawCircleHelper(int8_t x0, int8_t y0, int8_t r, uint8_t cornername);
      void fillCircle(int8_t x0, int8_t y0, int8_t r);
      void fillCircleHelper(int8_t x0, int8_t y0, int8_t r, uint8_t cornername, int8_t delta);

      void drawTriangle(int8_t x0, int8_t y0, int8_t x1, int8_t y1, int8_t x2, int8_t y2);
      void fillTriangle(int8_t x0, int8_t y0, int8_t x1, int8_t y1, int8_t x2, int8_t y2);
      void drawRoundRect(int8_t x0, int8_t y0, int8_t w, int8_t h, int8_t radius);
      void fillRoundRect(int8_t x0, int8_t y0, int8_t w, int8_t h, int8_t radius);

      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);
      boolean getBitmapPixel(const uint8_t* bitmap, uint8_t x, uint8_t y);

      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);

      void setFont(const uint8_t* f);
      uint8_t fontWidth, fontHeight;
      void drawChar(int8_t x, int8_t y, unsigned char c, uint8_t size);

      virtual size_t write(uint8_t);

      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;
     
      void setbracklight(uint8_t pmw); // needed?
  //// stopped here
     
//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

User avatar
Duhjoker
 
Posts: 446
Joined: Sat Jul 02, 2016 4:57 am
Location: Where Palm trees grow

Re: Color display library

Postby Duhjoker » Tue Sep 06, 2016 3:03 am

Ok I know I will have to change the pinouts on the gb settings file but I was looking and it seems the LCD needs adafruit_gfx to control the graphics. So I've been looking at that and I'm wondering since I'm changing the lcd_2000-7775 .h what parts I might need added to the .h file. I think the gfx file has most of the color bits for using 256K but I can't really tell which and what needs to be transferred.

Code: Select all


#ifndef _ADAFRUIT_GFX_H
#define _ADAFRUIT_GFX_H
#if ARDUINO >= 100
#include "Arduino.h"
#include "Print.h"
#else
#include "WProgram.h"
#endif
#include "gfxfont.h"
class Adafruit_GFX : public Print {
public:
Adafruit_GFX(int16_t w, int16_t h); // Constructor
// This MUST be defined by the subclass:
virtual void drawPixel(int16_t x, int16_t y, uint16_t color) = 0;
// These MAY be overridden by the subclass to provide device-specific
// optimized code. Otherwise 'generic' versions are used.
virtual void
drawLine(int16_t x0, int16_t y0, int16_t x1, int16_t y1, uint16_t color),
drawFastVLine(int16_t x, int16_t y, int16_t h, uint16_t color),
drawFastHLine(int16_t x, int16_t y, int16_t w, uint16_t color),
drawRect(int16_t x, int16_t y, int16_t w, int16_t h, uint16_t color),
fillRect(int16_t x, int16_t y, int16_t w, int16_t h, uint16_t color),
fillScreen(uint16_t color),
invertDisplay(boolean i);
// These exist only with Adafruit_GFX (no subclass overrides)
void
drawCircle(int16_t x0, int16_t y0, int16_t r, uint16_t color),
drawCircleHelper(int16_t x0, int16_t y0, int16_t r, uint8_t cornername,
uint16_t color),
fillCircle(int16_t x0, int16_t y0, int16_t r, uint16_t color),
fillCircleHelper(int16_t x0, int16_t y0, int16_t r, uint8_t cornername,
int16_t delta, uint16_t color),
drawTriangle(int16_t x0, int16_t y0, int16_t x1, int16_t y1,
int16_t x2, int16_t y2, uint16_t color),
fillTriangle(int16_t x0, int16_t y0, int16_t x1, int16_t y1,
int16_t x2, int16_t y2, uint16_t color),
drawRoundRect(int16_t x0, int16_t y0, int16_t w, int16_t h,
int16_t radius, uint16_t color),
fillRoundRect(int16_t x0, int16_t y0, int16_t w, int16_t h,
int16_t radius, uint16_t color),
drawBitmap(int16_t x, int16_t y, const uint8_t *bitmap,
int16_t w, int16_t h, uint16_t color),
drawBitmap(int16_t x, int16_t y, const uint8_t *bitmap,
int16_t w, int16_t h, uint16_t color, uint16_t bg),
drawBitmap(int16_t x, int16_t y, uint8_t *bitmap,
int16_t w, int16_t h, uint16_t color),
drawBitmap(int16_t x, int16_t y, uint8_t *bitmap,
int16_t w, int16_t h, uint16_t color, uint16_t bg),
drawXBitmap(int16_t x, int16_t y, const uint8_t *bitmap,
int16_t w, int16_t h, uint16_t color),
drawChar(int16_t x, int16_t y, unsigned char c, uint16_t color,
uint16_t bg, uint8_t size),
setCursor(int16_t x, int16_t y),
setTextColor(uint16_t c),
setTextColor(uint16_t c, uint16_t bg),
setTextSize(uint8_t s),
setTextWrap(boolean w),
setRotation(uint8_t r),
cp437(boolean x=true),
setFont(const GFXfont *f = NULL),
getTextBounds(char *string, int16_t x, int16_t y,
int16_t *x1, int16_t *y1, uint16_t *w, uint16_t *h),
getTextBounds(const __FlashStringHelper *s, int16_t x, int16_t y,
int16_t *x1, int16_t *y1, uint16_t *w, uint16_t *h);
#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;
};
class Adafruit_GFX_Button {
public:
Adafruit_GFX_Button(void);
void initButton(Adafruit_GFX *gfx, int16_t x, int16_t y,
uint8_t w, uint8_t h, uint16_t outline, uint16_t fill,
uint16_t textcolor, char *label, uint8_t textsize);
void drawButton(boolean inverted = false);
boolean contains(int16_t x, int16_t y);
void press(boolean p);
boolean isPressed();
boolean justPressed();
boolean justReleased();
private:
Adafruit_GFX *_gfx;
int16_t _x, _y;
uint16_t _w, _h;
uint8_t _textsize;
uint16_t _outlinecolor, _fillcolor, _textcolor;
char _label[10];
boolean currstate, laststate;
};
class GFXcanvas1 : public Adafruit_GFX {
public:
GFXcanvas1(uint16_t w, uint16_t h);
~GFXcanvas1(void);
void drawPixel(int16_t x, int16_t y, uint16_t color),
fillScreen(uint16_t color);
uint8_t *getBuffer(void);
private:
uint8_t *buffer;
};


Edit::::::

If you look at the file above you will see that it gives 5 different commands for bit map. But every thing else is only listed once. I think this allows for bit maps that contain different colors.

Would it be easier to add functions for the tile map routines into both the LCD 2000_7775 file and the GFX file? From what I can see they would be the only thing missing. Then I could simply add the LCD-2000_7775.h to any GB game sketch to use that instead of the standard display.h file.
User avatar
Duhjoker
 
Posts: 446
Joined: Sat Jul 02, 2016 4:57 am
Location: Where Palm trees grow

Re: Color display library

Postby Duhjoker » Tue Sep 06, 2016 10:06 am

Ok so I opened up VS and opened copies of display.h, lcd2000_7775.h and adafruit_gfx.h and added and updated the lcd file so it matched the display.h file as best as possible but it did give me green bars on the sides when I saved. I then added the tilemap commands to the gfx and a couple other things that needed. the only thing I didn't add was the rotation function since I couldn't figure out how to add it without the set color functions since the gfx library takes care of that I assume.

Heres the GB display.h file

Code: Select all
#ifndef DISPLAY_H
#define   DISPLAY_H

#include <Arduino.h>
#include <avr/pgmspace.h>
#include <SPI.h>

#include "settings.c"

//colors
#define WHITE 0
#define BLACK 1
#define INVERT 2
#define GRAY 3

//for extended bitmap function :
#define NOROT 0
#define ROTCCW 1
#define ROT180 2
#define ROTCW 3
#define NOFLIP 0
#define FLIPH 1
#define FLIPV 2
#define FLIPVH 3

#if (DISPLAY_ROT == NO_ROT)||(DISPLAY_ROT == ROT180) //landscape mode
#define LCDWIDTH 84
#define LCDHEIGHT 48
#else //portrait mode
#define LCDWIDTH 48
#define LCDHEIGHT 84
#endif
#define LCDHEIGHT_NOROT 48
#define LCDWIDTH_NOROT 84

#define swap(a, b) { int8_t t = a; a = b; b = t; }

#define PCD8544_POWERDOWN 0x04
#define PCD8544_ENTRYMODE 0x02
#define PCD8544_EXTENDEDINSTRUCTION 0x01

#define PCD8544_DISPLAYBLANK 0x0
#define PCD8544_DISPLAYNORMAL 0x4
#define PCD8544_DISPLAYALLON 0x1
#define PCD8544_DISPLAYINVERTED 0x5

// H = 0
#define PCD8544_FUNCTIONSET 0x20
#define PCD8544_DISPLAYCONTROL 0x08
#define PCD8544_SETYADDR 0x40
#define PCD8544_SETXADDR 0x80
#define PCD8544_SETXADDR 0x80

// H = 1
#define PCD8544_SETTEMP 0x04
#define PCD8544_SETBIAS 0x10
#define PCD8544_SETVOP 0x80

extern uint8_t _displayBuffer[];

class Display : public Print {
public:
   void begin(int8_t SCLK, int8_t DIN, int8_t DC, int8_t CS, int8_t RST);

   void command(uint8_t c);
   void data(uint8_t c);
   uint8_t* getBuffer();

   void setContrast(uint8_t val);
   void clear(void);
   void update();

   void setColor(int8_t c);
   void setColor(int8_t c, int8_t bg);
   inline void drawPixel(int8_t x, int8_t y);
   inline uint8_t getPixel(int8_t x, int8_t y);

   void drawLine(int8_t x0, int8_t y0, int8_t x1, int8_t y1);
   void drawFastVLine(int8_t x, int8_t y, int8_t h);
   void drawFastHLine(int8_t x, int8_t y, int8_t w);
   void drawRect(int8_t x, int8_t y, int8_t w, int8_t h);
   void fillRect(int8_t x, int8_t y, int8_t w, int8_t h);
   void fillScreen(uint8_t color);

   void drawCircle(int8_t x0, int8_t y0, int8_t r);
   void drawCircleHelper(int8_t x0, int8_t y0, int8_t r, uint8_t cornername);
   void fillCircle(int8_t x0, int8_t y0, int8_t r);
   void fillCircleHelper(int8_t x0, int8_t y0, int8_t r, uint8_t cornername, int8_t delta);

   void drawTriangle(int8_t x0, int8_t y0, int8_t x1, int8_t y1, int8_t x2, int8_t y2);
   void fillTriangle(int8_t x0, int8_t y0, int8_t x1, int8_t y1, int8_t x2, int8_t y2);
   void drawRoundRect(int8_t x0, int8_t y0, int8_t w, int8_t h, int8_t radius);
   void fillRoundRect(int8_t x0, int8_t y0, int8_t w, int8_t h, int8_t radius);
   
   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);
   boolean getBitmapPixel(const uint8_t* bitmap, uint8_t x, uint8_t y);
   
   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);
   
   void setFont(const uint8_t* f);
   uint8_t fontWidth, fontHeight;
   void drawChar(int8_t x, int8_t y, unsigned char c, uint8_t size);

   virtual size_t write(uint8_t);
   
   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;   
   
   
private:
   int8_t sclk, din, dc, cs, rst;
   volatile uint8_t *mosiport, *clkport, *csport, *dcport;
   uint8_t mosipinmask, clkpinmask, cspinmask, dcpinmask;
   
   uint8_t *font;
   uint8_t color, bgcolor;
};

inline uint8_t* Display::getBuffer(){
   return _displayBuffer;
}

inline void Display::drawPixel(int8_t x, int8_t y) {
   if ((x < 0) || (x >= LCDWIDTH) || (y < 0) || (y >= LCDHEIGHT))
   return;
   
   byte c = color;
   if(color == INVERT){
    c = !getPixel(x, y);
   } else if(color == GRAY){
      if(((frameCount & 0x01) ^ ((x & 0x01) ^ (y & 0x01)) == 0)){ //alternative checkers pattern
         c = WHITE;
      } else {
         c= BLACK;
      }
   }
   
   if(c == WHITE){ //white
#if DISPLAY_ROT == NOROT
      _displayBuffer[x + (y / 8) * LCDWIDTH_NOROT] &= ~_BV(y % 8);
#elif DISPLAY_ROT == ROTCCW
      _displayBuffer[LCDHEIGHT - y - 1 + (x / 8) * LCDWIDTH_NOROT] &= ~_BV(x % 8);
#elif DISPLAY_ROT == ROT180
      _displayBuffer[LCDWIDTH - x - 1 + ((LCDHEIGHT - y - 1) / 8) * LCDWIDTH_NOROT] &= ~_BV((LCDHEIGHT - y - 1) % 8);
#elif DISPLAY_ROT == ROTCW
      _displayBuffer[y + ((LCDWIDTH - x - 1) / 8) * LCDWIDTH_NOROT] &= ~_BV((LCDWIDTH - x - 1) % 8);
#endif
      return;
   }
   else { //black
#if DISPLAY_ROT == NOROT
      _displayBuffer[x + (y / 8) * LCDWIDTH_NOROT] |= _BV(y % 8);
#elif DISPLAY_ROT == ROTCCW
      _displayBuffer[LCDHEIGHT - y - 1 + (x / 8) * LCDWIDTH_NOROT] |= _BV(x % 8);
#elif DISPLAY_ROT == ROT180
      _displayBuffer[LCDWIDTH - x - 1 + ((LCDHEIGHT - y - 1) / 8) * LCDWIDTH_NOROT] |= _BV((LCDHEIGHT - y - 1) % 8);
#elif DISPLAY_ROT == ROTCW
      _displayBuffer[y + ((LCDWIDTH - x - 1) / 8) * LCDWIDTH_NOROT] |= _BV((LCDWIDTH - x -1) % 8);
#endif
      return;
   }
}

inline uint8_t Display::getPixel(int8_t x, int8_t y) {
   if ((x < 0) || (x >= LCDWIDTH) || (y < 0) || (y >= LCDHEIGHT))
   return 0;

   return (_displayBuffer[x + (y / 8) * LCDWIDTH] >> (y % 8)) & 0x1;
}


#endif   /* DISPLAY_H */



Heres the lcd.h file with new commands and updates

Code: Select all
#ifndef LCD_2000_7775_H
#define LCD_2000_7775_H

#include <Arduino.h>
#include <avr/pgmspace.h>
#include <SPI.h>

#include "settings.c"

//#if ARDUINO >= 100
// #include <Arduino.h>
// #include <Print.h>
//#else
// #include "WProgram.h"
//#endif
//#include "utility/Adafruit_GFX.h"

//#include <avr/pgmspace.h>


#define LCD_2000_7775_TFTWIDTH 220 //landscape
#define LCD_2000_7775_TFTHEIGHT 176

#define PCD8544_POWERDOWN 0x04
#define PCD8544_ENTRYMODE 0x02
#define PCD8544_EXTENDEDINSTRUCTION 0x01

#define PCD8544_DISPLAYBLANK 0x0
#define PCD8544_DISPLAYNORMAL 0x4
#define PCD8544_DISPLAYALLON 0x1
#define PCD8544_DISPLAYINVERTED 0x5

// H = 0
#define PCD8544_FUNCTIONSET 0x20
#define PCD8544_DISPLAYCONTROL 0x08
#define PCD8544_SETYADDR 0x40
#define PCD8544_SETXADDR 0x80
#define PCD8544_SETXADDR 0x80

// H = 1
#define PCD8544_SETTEMP 0x04
#define PCD8544_SETBIAS 0x10
#define PCD8544_SETVOP 0x80

extern uint8_t _displayBuffer[];

class LCD_2000_7775 : public Adafruit_GFX
{
   public:
      void begin(int8_t SCLK, int8_t DIN, int8_t DC, int8_t CS, int8_t RST);

      void command(uint8_t c);
      void data(uint8_t c);
      uint8_t* getBuffer();

      void setContrast(uint8_t val);
      void clear(void);
      void update();

      LCD_2000_7775(uint8_t cs,uint8_t wr ,uint8_t rs , uint8_t rest ,uint8_t pmw );
      LCD_2000_7775(uint8_t cs,uint8_t wr ,uint8_t rs , uint8_t rest );
      LCD_2000_7775(uint8_t cs,uint8_t wr ,uint8_t rs );
      //LCD_2000_7775(){};
      void write_spi(const uint8_t data);
 inline void drawPixel(int8_t x, int8_t y, uint8_t color);
 inline uint8_t getPixel(int8_t x, int8_t y );

      void setdatapin(uint8_t b0,uint8_t b1, uint8_t b2 , uint16_t b3,
                               uint8_t b4, uint8_t b5, uint8_t b6, uint8_t b7);

      void drawLine(int8_t x0, int8_t y0, int8_t x1, int8_t y1);
      void drawFastVLine(int8_t x, int8_t y, int8_t h );
      void drawFastHLine(int8_t x, int8_t y, int8_t w);
      void drawRect(int8_t x, int8_t y, int8_t w, int8_t h);
      //void fillRect(int8_t x, int8_t y, int8_t w, int8_t h);
      void fillScreen(uint8_t color);
      void fillRect(int8_t x, int8_t y, int8_t w, int16_t h,
      uint16_t color);
      
      void drawCircle(int8_t x0, int8_t y0, int8_t r);
      void drawCircleHelper(int8_t x0, int8_t y0, int8_t r, uint8_t cornername);
      void fillCircle(int8_t x0, int8_t y0, int8_t r);
      void fillCircleHelper(int8_t x0, int8_t y0, int8_t r, uint8_t cornername, int8_t delta);

      void drawTriangle(int8_t x0, int8_t y0, int8_t x1, int8_t y1, int8_t x2, int8_t y2);
      void fillTriangle(int8_t x0, int8_t y0, int8_t x1, int8_t y1, int8_t x2, int8_t y2);
      void drawRoundRect(int8_t x0, int8_t y0, int8_t w, int8_t h, int8_t radius);
      void fillRoundRect(int8_t x0, int8_t y0, int8_t w, int8_t h, int8_t radius);

      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);
      boolean getBitmapPixel(const uint8_t* bitmap, uint8_t x, uint8_t y);

      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);

      void setFont(const uint8_t* f);
      uint8_t fontWidth, fontHeight;
      void drawChar(int8_t x, int8_t y, unsigned char c, uint8_t size);

      virtual size_t write(uint8_t);

      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;

      void setbracklight(uint8_t pmw);
      
      //void begin();
      //void begin(int8_t SCLK, int8_t DIN, int8_t DC, int8_t CS, int8_t RST);
      
      //void drawbitmap(uint16_t* data, uint16_t x ,uint16_t y,uint16_t with , uint16_t height);
      
//fuction
   private:
      int8_t sclk, din, dc, cs, rst;
      volatile uint8_t *mosiport, *clkport, *csport, *dcport;
      uint8_t mosipinmask, clkpinmask, cspinmask, dcpinmask;

      uint8_t *font;
      uint8_t color, bgcolor;
};

inline uint8_t* Display::getBuffer() {
   return _displayBuffer;
}

inline void Display::drawPixel(int8_t x, int8_t y) {
   if ((x < 0) || (x >= LCDWIDTH) || (y < 0) || (y >= LCDHEIGHT))
      return;

}

      void set_window(uint8_t x1,uint8_t y1,uint8_t x2,uint8_t y2);
      void write_wr_reg(uint8_t data);
      void write_wr_data(uint8_t data);
      void write_cmd(uint8_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
};

inline uint8_t Display::getPixel(int8_t x, int8_t y) {
   if ((x < 0) || (x >= LCDWIDTH) || (y < 0) || (y >= LCDHEIGHT))
      return 0;

   return (_displayBuffer[x + (y / 8) * LCDWIDTH] >> (y % 8)) & 0x1;
}

uint16_t RGB(uint16_t r,uint16_t g , uint16_t b);

#endif


And lastly the gfx.h file with tilemap added


Code: Select all
#ifndef _ADAFRUIT_GFX_H
#define _ADAFRUIT_GFX_H

#if ARDUINO >= 100
 #include "Arduino.h"
 #include "Print.h"
#else
 #include "WProgram.h"
#endif

#include "gfxfont.h"

class Adafruit_GFX : public Print {

 public:

  Adafruit_GFX(int8_t w, int8_t h); // Constructor

  // This MUST be defined by the subclass:
  virtual void drawPixel(int8_t x, int8_t y, uint8_t color) = 0;

  // These MAY be overridden by the subclass to provide device-specific
  // optimized code.  Otherwise 'generic' versions are used.
  virtual void
    drawLine(int8_t x0, int8_t y0, int8_t x1, int8_t y1, uint8_t color),
    drawFastVLine(int8_t x, int8_t y, int8_t h, uint8_t color),
    drawFastHLine(int8_t x, int8_t y, int8_t w, uint8_t color),
    drawRect(int8_t x, int8_t y, int8_t w, int8_t h, uint8_t color),
    fillRect(int8_t x, int8_t y, int8_t w, int8_t h, uint8_t color),
    fillScreen(uint8_t color),
    invertDisplay(boolean i);

  // These exist only with Adafruit_GFX (no subclass overrides)
  void
    drawCircle(int8_t x0, int8_t y0, int8_t r, uint8_t color),
    drawCircleHelper(int8_t x0, int8_t y0, int8_t r, uint8_t cornername,
      uint8_t color),
    fillCircle(int8_t x0, int8_t y0, int8_t r, uint8_t color),
    fillCircleHelper(int8_t x0, int8_t y0, int8_t r, uin8_t cornername,
      int8_t delta, uint8_t color),
    drawTriangle(int8_t x0, int8_t y0, int8_t x1, int8_t y1,
      int8_t x2, int8_t y2, uint8_t color),
    fillTriangle(int8_t x0, int8_t y0, int8_t x1, int8_t y1,
      int8_t x2, int8_t y2, uint8_t color),
    drawRoundRect(int8_t x0, int8_t y0, int8_t w, int8_t h,
      int8_t radius, uint8_t color),
    fillRoundRect(int8_t x0, int8_t y0, int8_t w, int8_t h,
      int8_t radius, uint8_t color),
    drawBitmap(int8_t x, int8_t y, const uint8_t *bitmap,
      int8_t w, int8_t h, uint8_t color),
    drawBitmap(int8_t x, int8_t y, const uint8_t *bitmap,
      int8_t w, int8_t h, uint8_t color, uint8_t bg),
    drawBitmap(int8_t x, int8_t y, uint8_t *bitmap,
      int8_t w, int8_t h, uint8_t color),
    drawBitmap(int8_t x, int8_t y, uint8_t *bitmap,
      int8_t w, int8_t h, uint8_t color, uint8_t bg),
    drawXBitmap(int8_t x, int8_t y, const uint8_t *bitmap,
      int8_t w, int8_t h, uint8_t color),
    drawChar(int8_t x, int8_t y, unsigned char c, uint8_t color,
      uint8_t bg, uint8_t size),
   drawTilemap(int x, int y, const uint8_t *tilemap, const uint8_t **spritesheet),
    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),
    setCursor(int8_t x, int8_t y),
    setTextColor(uint8_t c),
    setTextColor(uint8_t c, uint16_t bg),
    setTextSize(uint8_t s),
    setTextWrap(boolean w),
    setRotation(uint8_t r),
    cp437(boolean x=true),
    setFont(const GFXfont *f = NULL),
    getTextBounds(char *string, int8_t x, int8_t y,
      int8_t *x1, int8_t *y1, uint8_t *w, uint8_t *h),
    getTextBounds(const __FlashStringHelper *s, int8_t x, int8_t y,
      int8_t *x1, int8_t *y1, uint8_t *w, uint8_t *h);

#if ARDUINO >= 100
  virtual size_t write(uint8_t);
#else
  virtual void   write(uint8_t);
#endif

  int8_t height(void) const;
  int8_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)
  int8_t getCursorX(void) const;
  int8_t getCursorY(void) const;

 protected:
  const int8_t
    WIDTH, HEIGHT;   // This is the 'raw' display w/h - never changes
  int8_t
    _width, _height, // Display w/h as modified by current rotation
    cursor_x, cursor_y;
  uint8_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;
};

class Adafruit_GFX_Button {

 public:
  Adafruit_GFX_Button(void);
  void initButton(Adafruit_GFX *gfx, int8_t x, int8_t y,
   uint8_t w, uint8_t h, uint8_t outline, uint8_t fill,
   uint8_t textcolor, char *label, uint8_t textsize);
  void drawButton(boolean inverted = false);
  boolean contains(int8_t x, int8_t y);

  void press(boolean p);
  boolean isPressed();
  boolean justPressed();
  boolean justReleased();

 private:
  Adafruit_GFX *_gfx;
  int8_t _x, _y;
  uint8_t _w, _h;
  uint8_t _textsize;
  uint8_t _outlinecolor, _fillcolor, _textcolor;
  char _label[10];

  boolean currstate, laststate;
};

class GFXcanvas1 : public Adafruit_GFX {

 public:
  GFXcanvas1(uint8_t w, uint8_t h);
  ~GFXcanvas1(void);
  void     drawPixel(int8_t x, int8_t y, uint8_t color),
           fillScreen(uint8_t color);
  uint8_t *getBuffer(void);
 private:
  uint8_t *buffer;
};

class GFXcanvas16 : public Adafruit_GFX {
  GFXcanvas8(uint8_t w, uint8_t h);
  ~GFXcanvas8(void);
  void      drawPixel(int8_t x, int8_t y, uint8_t color),
            fillScreen(uint8_t color);
  uint8_t *getBuffer(void);
 private:
  uint8_t *buffer;
};

#endif // _ADAFRUIT_GFX_H



ok could someone pretty please take a look at these and see if its feasible to work this way. I figure I can now use the lcd.h instead of display.h file.

now I just need to fix the c++ files and change the gb settings file
User avatar
Duhjoker
 
Posts: 446
Joined: Sat Jul 02, 2016 4:57 am
Location: Where Palm trees grow

Re: Color display library

Postby jonnection » Tue Sep 06, 2016 6:58 pm

ok could someone pretty please take a look at these and see if its feasible to work this way. I figure I can now use the lcd.h instead of display.h file.


Hello Duhjoker. I'm going to answer this. I see you are asking the same thing at Arduboy forums.

The biggest problem is that one pixel on a color display typically takes 16 bits of data = 16x more than one black-and-white pixel Arduboy and Gamebuino. So in order to make a decent game console that runs in color, you need to move data really fast. As soon as you get that SPI screen working, you will notice, like many many others before you (including myself), that you're able to get 2-5 frames per second max, a bit more with optimization. That's the real reason why there are no color versions of Arduboy and Gamebuino yet. It is technically quite challenging.

You can do color screen easily with a SOC (system on chip) with an integrated GPU but then you're already talking about an embedded linux system, like Raspberry Pi or the PocketChip. On an simple MCU like on Arduboy its a different matter altogether. There are MCU's with integrated LCD drivers, such as the FSMC bus on the STM32 Cortexes, but they are expensive and large chips.

I have already made both Arduino and Gameboy libraries in color & have them running at 20-30 fps depending on the game. It has taken me almost a year, and the code is optimized like crazy. I am not trying to dampen your enthusiasm, but it takes a serious amount of optimization to get enough speed out of a color display.
User avatar
jonnection
 
Posts: 317
Joined: Sun May 04, 2014 8:21 pm

Re: Color display library

Postby Duhjoker » Tue Sep 06, 2016 11:02 pm

Thanks for the reply. To be honest I'm Just trying to find some help, I keep being told to ask questions to which I ask a lot but they are mainly ignored. I've asked several times about the crystal in the schematics for instance in a couple different threads.

If it takes me a year it takes me a year but I would really appreciate if some one could just try to help me. I know this can be done but I'm still learning to code so I'm trying find what ever info and help I can find.

I'm actually using a teensy 3.2 for the MCU which has a 32-bit processor and 256K memory so I'm set on that part. I just need help doing the library to match my hardware. I.e. Color LCD.

I hope I haven't sounded like a troll. I'm not trying to be one I'm just stating the facts.

And I do appreciate all the help. If it weren't for the help and people here I would still be stuck trying to print a bitmap on the GB. And by the way I'm not interested in making any thing out of this. It's an open project that can be utilized by any one that wants to make one.
User avatar
Duhjoker
 
Posts: 446
Joined: Sat Jul 02, 2016 4:57 am
Location: Where Palm trees grow

Re: Color display library

Postby jonnection » Wed Sep 07, 2016 6:35 am

Duhjoker wrote:Thanks for the reply. To be honest I'm Just trying to find some help, I keep being told to ask questions to which I ask a lot but they are mainly ignored.


Hi Duhjoker

I didn't mean to be mean at all. I see you are very interested in this, and that is why I am not ignoring you. I am just saying that most people can't answer you because what you're trying to do is really not that easy. I think it was your question about the SPI bus I answered and again I have to say there is no simple answer to your question. You need to first understand what you're trying to do before digging into small details.

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

If you try to jump to #4 (as in my opinion you are trying to do, sorry if I have misunderstood you) you are attacking many things at once. This leads to complicated questions (because they involve pinout of the screens, driving them, how Gamebuino & Adafruit libraries work at the same time). Most likely those kind of questions will continue to be ignored. If however, you ask about fitting Nokia 5110 lcd to the Teensy, you will easily find information and people who have done it and will help you. Go step by step, solve one problem at a time. Make proof-of-concept of each step.
User avatar
jonnection
 
Posts: 317
Joined: Sun May 04, 2014 8:21 pm

Re: Color display library

Postby Duhjoker » Wed Sep 07, 2016 7:07 am

Its cool i was a lil aggravated myself and i apolagize.

Well you are right i am trying to do the hardware and the software at once and i should do one or the other. I do have a habit of jumping ahead of myself.

I dont know what got into me last night while i was working on the library and managed to get a pretty decent amount of work done. But i studied disply.h, LCD_2000_7775.h and the Adafruit_GFX.h files for days.

I tried to compile it today and only got one error. I renamed the lcd and gfx files by adding an R at the end before the .h and it doesnt like the way i renamed so i need to fix that and i might be able to compile a bitmap image.

I did a lil research and the LCD gets all its graphics programming from the adafruit library so that part was just adding a few commands. The GFX library also has i just found out the correct pin out for the screen. Well to an uno but i think i can easily do that part now.

What i will need to do is find all the pins designations in the code and match them to the LCD's pinout. So instead of all the scr_junk in the settings file i add the new pinout to each file that uses it.



Edit:

I've been looking at the cpp files for LCD 2000_7775 and the GFX and display and I don't see any thing I need to change. I'm getting an "" error though when I compile. What's the difference between "" and <>. Also if I have changed the GFX file to GFXR then does everything that's named GFX need to change to GFXR.

The cpp files for the GFX and the LCD file have the correct pin out so yay!!
User avatar
Duhjoker
 
Posts: 446
Joined: Sat Jul 02, 2016 4:57 am
Location: Where Palm trees grow

Re: Color display library

Postby Duhjoker » Sat Sep 10, 2016 9:26 pm

Ok I tried something a lil different. Instead of trying to collaborate all the files to create a new library I decided to just replace the gb display with the LCD library. I've managed to get the libraries to accept the new stuff but now I'm getting problems about the color bits from display.h
User avatar
Duhjoker
 
Posts: 446
Joined: Sat Jul 02, 2016 4:57 am
Location: Where Palm trees grow

Re: Color display library

Postby Duhjoker » Mon Sep 12, 2016 3:16 am

Lol really lol....

Ok so I decided to go a different route. Instead of trying to combine libraries to create a single new library wasn't going to work at least not the way I was going about. So I came up with plan B.

Plan B is to try to get the Gamebuino library to work with the new LCD library instead of display.h. So I went about just adding what I needed to be able to draw every thing including the tile map routine. I would then try to compile and get warnings. About the SD library and load image() and sd(). So I wanted to fix this. Turns out all I had to do was #include "sd.h" before the define of adafruit_gfx_h. So that fixed that.

So the funny part is that I didn't realize that LCD_2000_7775 had its own GFX library.... So all these changes I've been making were for the teensy GFX file so that's why I couldn't get the warning to disappear before doing the earlier. Guess I should have put that first.

Ok so now I just simply made copies of the LCD's GFX files and replaced them with my teensy GFX files and I seem to be closer now.


ok so I want to share the code so far.......here is the updated lcd_2000_7775 file that should go into the LCD's library file. (save the og first).

Code: Select all
#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>


#define LCD_2000_7775_TFTWIDTH 220  //changed to landscape
#define LCD_2000_7775_TFTHEIGHT 176 //changed to landscape

//#define swap(a, b) { int8_t t = a; a = b; b = t; }  //added by duhjoker from display.h

#define PCD8544_POWERDOWN 0x04             //added by duhjoker from display.h
#define PCD8544_ENTRYMODE 0x02             //added by duhjoker from display.h
#define PCD8544_EXTENDEDINSTRUCTION 0x01   //added by duhjoker from display.h         

#define PCD8544_DISPLAYBLANK 0x0           //added by duhjoker from display.h
#define PCD8544_DISPLAYNORMAL 0x4          //added by duhjoker from display.h
#define PCD8544_DISPLAYALLON 0x1           //added by duhjoker from display.h
#define PCD8544_DISPLAYINVERTED 0x5        //added by duhjoker from display.h   

// H = 0
#define PCD8544_FUNCTIONSET 0x20           //added by duhjoker from display.h
#define PCD8544_DISPLAYCONTROL 0x08        //added by duhjoker from display.h
#define PCD8544_SETYADDR 0x40              //added by duhjoker from display.h
#define PCD8544_SETXADDR 0x80              //added by duhjoker from display.h
#define PCD8544_SETXADDR 0x80              //added by duhjoker from display.h

// H = 1
#define PCD8544_SETTEMP 0x04               //added by duhjoker from display.h
#define PCD8544_SETBIAS 0x10               //added by duhjoker from display.h
#define PCD8544_SETVOP 0x80                //added by duhjoker from display.h

extern uint8_t _displayBuffer[];           //added by duhjoker from display.h


class LCD_2000_7775 : public Adafruit_GFX
{
   public:

      void begin(int8_t SCLK, int8_t DIN, int8_t DC, int8_t CS, int8_t RST); //added by duhjoker from display.h

      LCD_2000_7775(uint8_t cs,uint8_t wr ,uint8_t rs , uint8_t rest ,uint8_t pmw );
      LCD_2000_7775(uint8_t cs,uint8_t wr ,uint8_t rs , uint8_t rest );
      LCD_2000_7775(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);
      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 fillRect(int16_t x, int16_t y, int16_t w, int16_t h,
      uint16_t color);
      
      void setbracklight(uint8_t pmw);
      
      //void begin();
      //void begin(int8_t SCLK, int8_t DIN, int8_t DC, int8_t CS, int8_t RST); 
      
      void drawbitmap(uint16_t* data, uint16_t x ,uint16_t y,uint16_t with , uint16_t height);  //added by duhjoker from display.h
      
      void drawTilemap(int x, int y, const uint8_t *tilemap, const uint8_t **spritesheet);   //added by duhjoker from display.h summoner123
      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);  //added by duhjoker from display.h summoner123


//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



and here is the modified gfx.h file

Code: Select all

#ifndef _ADAFRUIT_GFX_H
#define _ADAFRUIT_GFX_H

#if ARDUINO >= 100
 #include "Arduino.h"
 #include "Print.h"
#else
 #include "WProgram.h"
#endif

#include "gfxfont.h"

class Adafruit_GFX : public Print {

 public:

  Adafruit_GFX(int16_t w, int16_t h); // Constructor

  // This MUST be defined by the subclass:
  virtual void drawPixel(int16_t x, int16_t y, uint16_t color) = 0;

  // These MAY be overridden by the subclass to provide device-specific
  // optimized code.  Otherwise 'generic' versions are used.
  virtual void
    drawLine(int16_t x0, int16_t y0, int16_t x1, int16_t y1, uint16_t color),
    drawFastVLine(int16_t x, int16_t y, int16_t h, uint16_t color),
    drawFastHLine(int16_t x, int16_t y, int16_t w, uint16_t color),
    drawRect(int16_t x, int16_t y, int16_t w, int16_t h, uint16_t color),
    fillRect(int16_t x, int16_t y, int16_t w, int16_t h, uint16_t color),
    fillScreen(uint16_t color),
    invertDisplay(boolean i);

  // These exist only with Adafruit_GFX (no subclass overrides)
  void
    drawCircle(int16_t x0, int16_t y0, int16_t r, uint16_t color),
    drawCircleHelper(int16_t x0, int16_t y0, int16_t r, uint8_t cornername,
      uint16_t color),
    fillCircle(int16_t x0, int16_t y0, int16_t r, uint16_t color),
    fillCircleHelper(int16_t x0, int16_t y0, int16_t r, uint8_t cornername,
      int16_t delta, uint16_t color),
    drawTriangle(int16_t x0, int16_t y0, int16_t x1, int16_t y1,
      int16_t x2, int16_t y2, uint16_t color),
    fillTriangle(int16_t x0, int16_t y0, int16_t x1, int16_t y1,
      int16_t x2, int16_t y2, uint16_t color),
    drawRoundRect(int16_t x0, int16_t y0, int16_t w, int16_t h,
      int16_t radius, uint16_t color),
    fillRoundRect(int16_t x0, int16_t y0, int16_t w, int16_t h,
      int16_t radius, uint16_t color),
    drawBitmap(int16_t x, int16_t y, const uint8_t *bitmap,
      int16_t w, int16_t h, uint16_t color),
    drawBitmap(int16_t x, int16_t y, const uint8_t *bitmap,
      int16_t w, int16_t h, uint16_t color, uint16_t bg),
    drawBitmap(int16_t x, int16_t y, uint8_t *bitmap,
      int16_t w, int16_t h, uint16_t color),
    drawBitmap(int16_t x, int16_t y, uint8_t *bitmap,
      int16_t w, int16_t h, uint16_t color, uint16_t bg),
    drawXBitmap(int16_t x, int16_t y, const uint8_t *bitmap,
      int16_t w, int16_t h, uint16_t color),
    //drawTilemap(int x, int y, const uint8_t *tilemap, const uint8_t **spritesheet);
    //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);
    drawChar(int16_t x, int16_t y, unsigned char c, uint16_t color,
      uint16_t bg, uint8_t size),
    setCursor(int16_t x, int16_t y),
    setTextColor(uint16_t c),
    setTextColor(uint16_t c, uint16_t bg),
    setTextSize(uint8_t s),
    setTextWrap(boolean w),
    setRotation(uint8_t r),
    cp437(boolean x=true),
    setFont(const GFXfont *f = NULL),
    getTextBounds(char *string, int16_t x, int16_t y,
      int16_t *x1, int16_t *y1, uint16_t *w, uint16_t *h),
    getTextBounds(const __FlashStringHelper *s, int16_t x, int16_t y,
      int16_t *x1, int16_t *y1, uint16_t *w, uint16_t *h);

#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;
};

class Adafruit_GFX_Button {

 public:
  Adafruit_GFX_Button(void);
  void initButton(Adafruit_GFX *gfx, int16_t x, int16_t y,
   uint8_t w, uint8_t h, uint16_t outline, uint16_t fill,
   uint16_t textcolor, char *label, uint8_t textsize);
  void drawButton(boolean inverted = false);
  boolean contains(int16_t x, int16_t y);

  void press(boolean p);
  boolean isPressed();
  boolean justPressed();
  boolean justReleased();

 private:
  Adafruit_GFX *_gfx;
  int16_t _x, _y;
  uint16_t _w, _h;
  uint8_t _textsize;
  uint16_t _outlinecolor, _fillcolor, _textcolor;
  char _label[10];

  boolean currstate, laststate;
};

class GFXcanvas1 : public Adafruit_GFX {

 public:
  GFXcanvas1(uint16_t w, uint16_t h);
  ~GFXcanvas1(void);
  void     drawPixel(int16_t x, int16_t y, uint16_t color),
           fillScreen(uint16_t color);
  uint8_t *getBuffer(void);
 private:
  uint8_t *buffer;
};

class GFXcanvas16 : public Adafruit_GFX {
  GFXcanvas16(uint16_t w, uint16_t h);
  ~GFXcanvas16(void);
  void      drawPixel(int16_t x, int16_t y, uint16_t color),
            fillScreen(uint16_t color);
  uint16_t *getBuffer(void);
 private:
  uint16_t *buffer;
};

#endif // _ADAFRUIT_GFX_H



here is the cpp file for the gfx file that shows to wires needed pretty much
Code: Select all
/*


#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...

// a 3x5 font table
extern const uint8_t font3x5[] PROGMEM;

// the memory buffer for the LCD
uint8_t _displayBuffer[512];

//the original display buffer containing the splash screen by Adafruit
//uint8_t pcd8544_buffer[LCDWIDTH * LCDHEIGHT / 8] = {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, 0xC0, 0xE0, 0xF0, 0xF8, 0xFC, 0xFC, 0xFE, 0xFF, 0xFC, 0xE0,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, 0xF8, 0xF8, 0xF8, 0xF8, 0xF8, 0xF8, 0xF8, 0xF8, 0xF8, 0xF8, 0xF8,0xF8, 0xF0, 0xF0, 0xE0, 0xE0, 0xC0, 0x80, 0xC0, 0xFC, 0xFF, 0xFF, 0xFF, 0xFF, 0x7F, 0x3F, 0x7F,0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 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, 0x0F, 0x1F, 0x3F, 0x7F, 0xFF, 0xFF,0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xE7, 0xC7, 0xC7, 0x87, 0x8F, 0x9F, 0x9F, 0xFF, 0xFF, 0xFF,0xC1, 0xC0, 0xE0, 0xFC, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFC, 0xFC, 0xFC, 0xFC, 0xFE, 0xFE, 0xFE,0xFC, 0xFC, 0xF8, 0xF8, 0xF0, 0xE0, 0xC0, 0xC0, 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, 0x80, 0xC0, 0xE0, 0xF1, 0xFB, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x7F, 0x1F, 0x0F, 0x0F, 0x87,0xE7, 0xFF, 0xFF, 0xFF, 0x1F, 0x1F, 0x3F, 0xF9, 0xF8, 0xF8, 0xF8, 0xF8, 0xF8, 0xF8, 0xFD, 0xFF,0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x7F, 0x3F, 0x0F, 0x07, 0x01, 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,x00, 0x00, 0x00, 0xF0, 0xFE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFE,0x7E, 0x3F, 0x3F, 0x0F, 0x1F, 0xFF, 0xFF, 0xFF, 0xFC, 0xF0, 0xE0, 0xF1, 0xFF, 0xFF, 0xFF, 0xFF,0xFF, 0xFC, 0xF0, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 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, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x01,0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x0F, 0x1F, 0x3F, 0x7F, 0x7F,0xFF, 0xFF, 0xFF, 0xFF, 0x7F, 0x7F, 0x1F, 0x03, 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, };

void Display::begin(int8_t SCLK, int8_t DIN, int8_t DC, int8_t CS, int8_t RST) {
   din = DIN;
   sclk = SCLK;
   dc = DC;
   rst = RST;
   cs = CS;

   //cursorY = cursorX = 0;
   fontSize = 1;
   color = BLACK;
   bgcolor = WHITE;
   textWrap = true;
   setFont(font3x5);
   //persistence = false;

   SPI.begin();
   SPI.setBitOrder(MSBFIRST);
   SPI.setClockDivider(SPI_CLOCK_DIV8); //can be set to 4 but some random pixels will start to appear on some displays
   SPI.setDataMode(SPI_MODE3);
   // set pin directions
   pinMode(din, OUTPUT);
   pinMode(sclk, OUTPUT);
   pinMode(dc, OUTPUT);
   if (rst > 0)
      pinMode(rst, OUTPUT);
   if (cs > 0)
      pinMode(cs, OUTPUT);

   // toggle RST low to reset
   if (rst > 0) {
      digitalWrite(rst, LOW);
      delay(10);
      digitalWrite(rst, HIGH);
   }

   clkport = portOutputRegister(digitalPinToPort(sclk));
   clkpinmask = digitalPinToBitMask(sclk);
   mosiport = portOutputRegister(digitalPinToPort(din));
   mosipinmask = digitalPinToBitMask(din);
   csport = portOutputRegister(digitalPinToPort(cs));
   cspinmask = digitalPinToBitMask(cs);
   dcport = portOutputRegister(digitalPinToPort(dc));
   dcpinmask = digitalPinToBitMask(dc);

   // get into the EXTENDED mode!
   command(PCD8544_FUNCTIONSET | PCD8544_EXTENDEDINSTRUCTION);

   // LCD bias select (4 is optimal?)
   command(PCD8544_SETBIAS | 0x4);

   // set VOP
   if (contrast > 0x7f)
      contrast = 0x7f;

   command(PCD8544_SETVOP | contrast); // Experimentally determined


                              // normal mode
   command(PCD8544_FUNCTIONSET);

   // Set display to Normal
   command(PCD8544_DISPLAYCONTROL | PCD8544_DISPLAYNORMAL);

   // initial display line
   // set page address
   // set column address
   // write display data

   update();
}

#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

Adafruit_GFX::Adafruit_GFX(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;
}

// Draw a circle outline
void Adafruit_GFX::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 Adafruit_GFX::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 Adafruit_GFX::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 Adafruit_GFX::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);
    }
  }
}

// Bresenham's algorithm - thx wikpedia
void Adafruit_GFX::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;
    }
  }
}

// Draw a rectangle
void Adafruit_GFX::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 Adafruit_GFX::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 Adafruit_GFX::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);
}

void Adafruit_GFX::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 Adafruit_GFX::fillScreen(uint16_t color) {
  fillRect(0, 0, _width, _height, color);
}

// Draw a rounded rectangle
void Adafruit_GFX::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 Adafruit_GFX::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 triangle
void Adafruit_GFX::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 Adafruit_GFX::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 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 Adafruit_GFX::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 Adafruit_GFX::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 Adafruit_GFX::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 Adafruit_GFX::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 Adafruit_GFX::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 Adafruit_GFX::write(uint8_t c) {
#else
void Adafruit_GFX::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 Adafruit_GFX::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 Adafruit_GFX::setCursor(int16_t x, int16_t y) {
  cursor_x = x;
  cursor_y = y;
}

int16_t Adafruit_GFX::getCursorX(void) const {
  return cursor_x;
}

int16_t Adafruit_GFX::getCursorY(void) const {
  return cursor_y;
}

void Adafruit_GFX::setTextSize(uint8_t s) {
  textsize = (s > 0) ? s : 1;
}

void Adafruit_GFX::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 Adafruit_GFX::setTextColor(uint16_t c, uint16_t b) {
  textcolor   = c;
  textbgcolor = b;
}

void Adafruit_GFX::setTextWrap(boolean w) {
  wrap = w;
}

uint8_t Adafruit_GFX::getRotation(void) const {
  return rotation;
}

void Adafruit_GFX::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 Adafruit_GFX::cp437(boolean x) {
  _cp437 = x;
}

void Adafruit_GFX::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 Adafruit_GFX::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 Adafruit_GFX::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 Adafruit_GFX::width(void) const {
  return _width;
}

int16_t Adafruit_GFX::height(void) const {
  return _height;
}

void Adafruit_GFX::invertDisplay(boolean i) {
  // Do nothing, must be subclassed if supported by hardware
}

/***************************************************************************/
// code for the GFX button UI element

Adafruit_GFX_Button::Adafruit_GFX_Button(void) {
  _gfx = 0;
}

void Adafruit_GFX_Button::initButton(
 Adafruit_GFX *gfx, int16_t x, int16_t y, uint8_t w, uint8_t h,
 uint16_t outline, uint16_t fill, uint16_t textcolor,
 char *label, uint8_t textsize)
{
  _x            = x;
  _y            = y;
  _w            = w;
  _h            = h;
  _outlinecolor = outline;
  _fillcolor    = fill;
  _textcolor    = textcolor;
  _textsize     = textsize;
  _gfx          = gfx;
  strncpy(_label, label, 9);
  _label[9] = 0;
}

void Adafruit_GFX_Button::drawButton(boolean inverted) {
  uint16_t fill, outline, text;

  if(!inverted) {
    fill    = _fillcolor;
    outline = _outlinecolor;
    text    = _textcolor;
  } else {
    fill    = _textcolor;
    outline = _outlinecolor;
    text    = _fillcolor;
  }

  _gfx->fillRoundRect(_x - (_w/2), _y - (_h/2), _w, _h, min(_w,_h)/4, fill);
  _gfx->drawRoundRect(_x - (_w/2), _y - (_h/2), _w, _h, min(_w,_h)/4, outline);

  _gfx->setCursor(_x - strlen(_label)*3*_textsize, _y-4*_textsize);
  _gfx->setTextColor(text);
  _gfx->setTextSize(_textsize);
  _gfx->print(_label);
}

boolean Adafruit_GFX_Button::contains(int16_t x, int16_t y) {
  if ((x < (_x - _w/2)) || (x > (_x + _w/2))) return false;
  if ((y < (_y - _h/2)) || (y > (_y + _h/2))) return false;
  return true;
}

void Adafruit_GFX_Button::press(boolean p) {
  laststate = currstate;
  currstate = p;
}

boolean Adafruit_GFX_Button::isPressed() { return currstate; }
boolean Adafruit_GFX_Button::justPressed() { return (currstate && !laststate); }
boolean Adafruit_GFX_Button::justReleased() { return (!currstate && laststate); }

// -------------------------------------------------------------------------

// GFXcanvas1 and GFXcanvas16 (currently a WIP, don't get too comfy with the
// implementation) provide 1- and 16-bit offscreen canvases, the address of
// which can be passed to drawBitmap() or pushColors() (the latter appears
// to only be in Adafruit_TFTLCD at this time).  This is here mostly to
// help with the recently-added proportionally-spaced fonts; adds a way to
// refresh a section of the screen without a massive flickering clear-and-
// redraw...but maybe you'll find other uses too.  VERY RAM-intensive, since
// the buffer is in MCU memory and not the display driver...GXFcanvas1 might
// be minimally useful on an Uno-class board, but this and GFXcanvas16 are
// much more likely to require at least a Mega or various recent ARM-type
// boards (recomment, as the text+bitmap draw can be pokey).  GFXcanvas1
// requires 1 bit per pixel (rounded up to nearest byte per scanline),
// GFXcanvas16 requires 2 bytes per pixel (no scanline pad).
// NOT EXTENSIVELY TESTED YET.  MAY CONTAIN WORST BUGS KNOWN TO HUMANKIND.

GFXcanvas1::GFXcanvas1(uint16_t w, uint16_t h) : Adafruit_GFX(w, h) {
  uint16_t bytes = ((w + 7) / 8) * h;
  if((buffer = (uint8_t *)malloc(bytes))) {
    memset(buffer, 0, bytes);
  }
}

GFXcanvas1::~GFXcanvas1(void) {
  if(buffer) free(buffer);
}

uint8_t* GFXcanvas1::getBuffer(void) {
  return buffer;
}

void GFXcanvas1::drawPixel(int16_t x, int16_t y, uint16_t color) {
  // Bitmask tables of 0x80>>X and ~(0x80>>X), because X>>Y is slow on AVR
  static const uint8_t PROGMEM
    GFXsetBit[] = { 0x80, 0x40, 0x20, 0x10, 0x08, 0x04, 0x02, 0x01 },
    GFXclrBit[] = { 0x7F, 0xBF, 0xDF, 0xEF, 0xF7, 0xFB, 0xFD, 0xFE };

  if(buffer) {
    if((x < 0) || (y < 0) || (x >= _width) || (y >= _height)) return;

    int16_t t;
    switch(rotation) {
     case 1:
      t = x;
      x = WIDTH  - 1 - y;
      y = t;
      break;
     case 2:
      x = WIDTH  - 1 - x;
      y = HEIGHT - 1 - y;
      break;
     case 3:
      t = x;
      x = y;
      y = HEIGHT - 1 - t;
      break;
    }

    uint8_t *ptr = &buffer[(x / 8) + y * ((WIDTH + 7) / 8)];
    if(color) *ptr |= pgm_read_byte(&GFXsetBit[x & 7]);
    else      *ptr &= pgm_read_byte(&GFXclrBit[x & 7]);
  }
}

void GFXcanvas1::fillScreen(uint16_t color) {
  if(buffer) {
    uint16_t bytes = ((WIDTH + 7) / 8) * HEIGHT;
    memset(buffer, color ? 0xFF : 0x00, bytes);
  }
}

GFXcanvas16::GFXcanvas16(uint16_t w, uint16_t h) : Adafruit_GFX(w, h) {
  uint16_t bytes = w * h * 2;
  if((buffer = (uint16_t *)malloc(bytes))) {
    memset(buffer, 0, bytes);
  }
}

GFXcanvas16::~GFXcanvas16(void) {
  if(buffer) free(buffer);
}

uint16_t* GFXcanvas16::getBuffer(void) {
  return buffer;
}

void GFXcanvas16::drawPixel(int16_t x, int16_t y, uint16_t color) {
  if(buffer) {
    if((x < 0) || (y < 0) || (x >= _width) || (y >= _height)) return;

    int16_t t;
    switch(rotation) {
     case 1:
      t = x;
      x = WIDTH  - 1 - y;
      y = t;
      break;
     case 2:
      x = WIDTH  - 1 - x;
      y = HEIGHT - 1 - y;
      break;
     case 3:
      t = x;
      x = y;
      y = HEIGHT - 1 - t;
      break;
    }

    buffer[x + y * WIDTH] = color;
  }
}

void GFXcanvas16::fillScreen(uint16_t color) {
  if(buffer) {
    uint8_t hi = color >> 8, lo = color & 0xFF;
    if(hi == lo) {
      memset(buffer, lo, WIDTH * HEIGHT * 2);
    } else {
      uint16_t i, pixels = WIDTH * HEIGHT;
      for(i=0; i<pixels; i++) buffer[i] = color;
    }
  }
}




here are my errors
Code: Select all
Arduino: 1.6.11 (Windows 7), TD: 1.30-beta3, Board: "Teensy 3.2 / 3.1, Serial, 96 MHz optimize speed (overclock), US English"

WARNING: Category '' in library LCD_2000_7775 is not valid. Setting to 'Uncategorized'
In file included from C:\Users\duhjoker\Desktop\Gamebuino_master\VERSIONS\ESMERELDA\ESMERELDA\ESMERELDA.ino:5:0:

C:\Users\duhjoker\Documents\Arduino\libraries\Gamebuinosummoner123/Gamebuino.h:44:5: error: 'Display' does not name a type

     Display display;

     ^

ESMERELDA: In function 'void loop()':
ESMERELDA:104: error: 'class Gamebuino' has no member named 'display'
     gb.display.drawBitmap(0,0,room_1);

        ^

ESMERELDA:107: error: 'class Gamebuino' has no member named 'display'
     gb.display.drawBitmap(player_x,player_y,sever_front_1);

        ^

C:\Users\duhjoker\Desktop\Gamebuino_master\VERSIONS\ESMERELDA\ESMERELDA\ESMERELDA.ino: At global scope:

ESMERELDA:114: error: expected unqualified-id before 'if'
     if(gb.buttons.repeat(BTN_UP,1)){

     ^

ESMERELDA:120: error: expected declaration before '}' token
     }

     ^

Multiple libraries were found for "gfxfont.h"
 Used: C:\Program Files (x86)\Arduino\hardware\teensy\avr\libraries\ssd1351
 Not used: C:\Program Files (x86)\Arduino\hardware\teensy\avr\libraries\Adafruit_GFX
 Not used: C:\Program Files (x86)\Arduino\hardware\teensy\avr\libraries\Adafruit_GFX
 Not used: C:\Program Files (x86)\Arduino\hardware\teensy\avr\libraries\Adafruit_GFX
 Not used: C:\Program Files (x86)\Arduino\hardware\teensy\avr\libraries\Adafruit_GFX
'class Gamebuino' has no member named 'display'

This report would have more information with
"Show verbose output during compilation"
option enabled in File -> Preferences.




Edit

I fixed some of the above, it was as simple as moving some brackets and marking some out.

But now I'm having the class problem saying display doesn't name a type in the Gamebuino.h library. I opened it up and tried to name Display lcd_2000_7775 but then it says error use of of deleted function Gamebuino() and whole bunch of other stuff
User avatar
Duhjoker
 
Posts: 446
Joined: Sat Jul 02, 2016 4:57 am
Location: Where Palm trees grow

Re: Color display library

Postby Duhjoker » Mon Sep 12, 2016 6:26 am

sorry could not add this to the edit above.

ok so after changing Display display; to LCD_2000_7775 display, it canceled out the gb command so I think I need to change the display commands in my sketch to LCD_2000_7775.display. I hope some one can help me here......

here are my errors
Code: Select all
Arduino: 1.6.11 (Windows 7), TD: 1.30-beta3, Board: "Teensy 3.2 / 3.1, Serial, 96 MHz optimize speed (overclock), US English"

WARNING: Category '' in library LCD_2000_7775 is not valid. Setting to 'Uncategorized'
ESMERELDA:7: error: use of deleted function 'Gamebuino::Gamebuino()'
 Gamebuino gb;

           ^

In file included from C:\Users\duhjoker\Desktop\Gamebuino_master\VERSIONS\ESMERELDA\ESMERELDA\ESMERELDA.ino:5:0:

C:\Users\duhjoker\Documents\Arduino\libraries\Gamebuinosummoner123/Gamebuino.h:38: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:38:7: error: no matching function for call to 'LCD_2000_7775::LCD_2000_7775()'

C:\Users\duhjoker\Documents\Arduino\libraries\Gamebuinosummoner123/Gamebuino.h:38:7: note: candidates are:

In file included from C:\Users\duhjoker\Desktop\Gamebuino_master\VERSIONS\ESMERELDA\ESMERELDA\ESMERELDA.ino:1:0:

C:\Users\duhjoker\Documents\Arduino\libraries\LCD_2000_7775\src/LCD_2000_7775.h:52:3: note: LCD_2000_7775::LCD_2000_7775(uint8_t, uint8_t, uint8_t)

   LCD_2000_7775(uint8_t cs,uint8_t wr ,uint8_t rs );

   ^

C:\Users\duhjoker\Documents\Arduino\libraries\LCD_2000_7775\src/LCD_2000_7775.h:52:3: note:   candidate expects 3 arguments, 0 provided

C:\Users\duhjoker\Documents\Arduino\libraries\LCD_2000_7775\src/LCD_2000_7775.h:51:3: note: LCD_2000_7775::LCD_2000_7775(uint8_t, uint8_t, uint8_t, uint8_t)

   LCD_2000_7775(uint8_t cs,uint8_t wr ,uint8_t rs , uint8_t rest );

   ^

C:\Users\duhjoker\Documents\Arduino\libraries\LCD_2000_7775\src/LCD_2000_7775.h:51:3: note:   candidate expects 4 arguments, 0 provided

C:\Users\duhjoker\Documents\Arduino\libraries\LCD_2000_7775\src/LCD_2000_7775.h:50:3: note: LCD_2000_7775::LCD_2000_7775(uint8_t, uint8_t, uint8_t, uint8_t, uint8_t)

   LCD_2000_7775(uint8_t cs,uint8_t wr ,uint8_t rs , uint8_t rest ,uint8_t pmw );

   ^

C:\Users\duhjoker\Documents\Arduino\libraries\LCD_2000_7775\src/LCD_2000_7775.h:50:3: note:   candidate expects 5 arguments, 0 provided

C:\Users\duhjoker\Documents\Arduino\libraries\LCD_2000_7775\src/LCD_2000_7775.h:44:7: note: constexpr LCD_2000_7775::LCD_2000_7775(const LCD_2000_7775&)

 class LCD_2000_7775 : public Adafruit_GFX

       ^

C:\Users\duhjoker\Documents\Arduino\libraries\LCD_2000_7775\src/LCD_2000_7775.h:44:7: note:   candidate expects 1 argument, 0 provided

C:\Users\duhjoker\Documents\Arduino\libraries\LCD_2000_7775\src/LCD_2000_7775.h:44:7: note: constexpr LCD_2000_7775::LCD_2000_7775(LCD_2000_7775&&)

C:\Users\duhjoker\Documents\Arduino\libraries\LCD_2000_7775\src/LCD_2000_7775.h:44:7: note:   candidate expects 1 argument, 0 provided

ESMERELDA: In function 'void loop()':
ESMERELDA:104: error: no matching function for call to 'LCD_2000_7775::drawBitmap(int, int, const byte [530])'
     gb.display.drawBitmap(0,0,room_1);

                                     ^

C:\Users\duhjoker\Desktop\Gamebuino_master\VERSIONS\ESMERELDA\ESMERELDA\ESMERELDA.ino:104:37: note: candidates are:

In file included from C:\Users\duhjoker\Documents\Arduino\libraries\LCD_2000_7775\src/LCD_2000_7775.h:10:0,

                 from C:\Users\duhjoker\Desktop\Gamebuino_master\VERSIONS\ESMERELDA\ESMERELDA\ESMERELDA.ino:1:

C:\Users\duhjoker\Documents\Arduino\libraries\LCD_2000_7775\src/utility/Adafruit_GFX.h:49:5: note: void Adafruit_GFX::drawBitmap(int16_t, int16_t, const uint8_t*, int16_t, int16_t, uint16_t)

     drawBitmap(int16_t x, int16_t y, const uint8_t *bitmap,

     ^

C:\Users\duhjoker\Documents\Arduino\libraries\LCD_2000_7775\src/utility/Adafruit_GFX.h:49:5: note:   candidate expects 6 arguments, 3 provided

C:\Users\duhjoker\Documents\Arduino\libraries\LCD_2000_7775\src/utility/Adafruit_GFX.h:51:5: note: void Adafruit_GFX::drawBitmap(int16_t, int16_t, const uint8_t*, int16_t, int16_t, uint16_t, uint16_t)

     drawBitmap(int16_t x, int16_t y, const uint8_t *bitmap,

     ^

C:\Users\duhjoker\Documents\Arduino\libraries\LCD_2000_7775\src/utility/Adafruit_GFX.h:51:5: note:   candidate expects 7 arguments, 3 provided

C:\Users\duhjoker\Documents\Arduino\libraries\LCD_2000_7775\src/utility/Adafruit_GFX.h:53:5: note: void Adafruit_GFX::drawBitmap(int16_t, int16_t, uint8_t*, int16_t, int16_t, uint16_t)

     drawBitmap(int16_t x, int16_t y, uint8_t *bitmap,

     ^

C:\Users\duhjoker\Documents\Arduino\libraries\LCD_2000_7775\src/utility/Adafruit_GFX.h:53:5: note:   candidate expects 6 arguments, 3 provided

C:\Users\duhjoker\Documents\Arduino\libraries\LCD_2000_7775\src/utility/Adafruit_GFX.h:55:5: note: void Adafruit_GFX::drawBitmap(int16_t, int16_t, uint8_t*, int16_t, int16_t, uint16_t, uint16_t)

     drawBitmap(int16_t x, int16_t y, uint8_t *bitmap,

     ^

C:\Users\duhjoker\Documents\Arduino\libraries\LCD_2000_7775\src/utility/Adafruit_GFX.h:55:5: note:   candidate expects 7 arguments, 3 provided

ESMERELDA:107: error: no matching function for call to 'LCD_2000_7775::drawBitmap(int&, int&, const byte [258])'
     gb.display.drawBitmap(player_x,player_y,sever_front_1);

                                                          ^

C:\Users\duhjoker\Desktop\Gamebuino_master\VERSIONS\ESMERELDA\ESMERELDA\ESMERELDA.ino:107:58: note: candidates are:

In file included from C:\Users\duhjoker\Documents\Arduino\libraries\LCD_2000_7775\src/LCD_2000_7775.h:10:0,

                 from C:\Users\duhjoker\Desktop\Gamebuino_master\VERSIONS\ESMERELDA\ESMERELDA\ESMERELDA.ino:1:

C:\Users\duhjoker\Documents\Arduino\libraries\LCD_2000_7775\src/utility/Adafruit_GFX.h:49:5: note: void Adafruit_GFX::drawBitmap(int16_t, int16_t, const uint8_t*, int16_t, int16_t, uint16_t)

     drawBitmap(int16_t x, int16_t y, const uint8_t *bitmap,

     ^

C:\Users\duhjoker\Documents\Arduino\libraries\LCD_2000_7775\src/utility/Adafruit_GFX.h:49:5: note:   candidate expects 6 arguments, 3 provided

C:\Users\duhjoker\Documents\Arduino\libraries\LCD_2000_7775\src/utility/Adafruit_GFX.h:51:5: note: void Adafruit_GFX::drawBitmap(int16_t, int16_t, const uint8_t*, int16_t, int16_t, uint16_t, uint16_t)

     drawBitmap(int16_t x, int16_t y, const uint8_t *bitmap,

     ^

C:\Users\duhjoker\Documents\Arduino\libraries\LCD_2000_7775\src/utility/Adafruit_GFX.h:51:5: note:   candidate expects 7 arguments, 3 provided

C:\Users\duhjoker\Documents\Arduino\libraries\LCD_2000_7775\src/utility/Adafruit_GFX.h:53:5: note: void Adafruit_GFX::drawBitmap(int16_t, int16_t, uint8_t*, int16_t, int16_t, uint16_t)

     drawBitmap(int16_t x, int16_t y, uint8_t *bitmap,

     ^

C:\Users\duhjoker\Documents\Arduino\libraries\LCD_2000_7775\src/utility/Adafruit_GFX.h:53:5: note:   candidate expects 6 arguments, 3 provided

C:\Users\duhjoker\Documents\Arduino\libraries\LCD_2000_7775\src/utility/Adafruit_GFX.h:55:5: note: void Adafruit_GFX::drawBitmap(int16_t, int16_t, uint8_t*, int16_t, int16_t, uint16_t, uint16_t)

     drawBitmap(int16_t x, int16_t y, uint8_t *bitmap,

     ^

C:\Users\duhjoker\Documents\Arduino\libraries\LCD_2000_7775\src/utility/Adafruit_GFX.h:55:5: note:   candidate expects 7 arguments, 3 provided

ESMERELDA:116: error: no matching function for call to 'LCD_2000_7775::drawBitmap(int&, int&, const byte [8])'
     gb.display.drawBitmap(player_x,player_y,sever_rear_1);

                                                         ^

C:\Users\duhjoker\Desktop\Gamebuino_master\VERSIONS\ESMERELDA\ESMERELDA\ESMERELDA.ino:116:57: note: candidates are:

In file included from C:\Users\duhjoker\Documents\Arduino\libraries\LCD_2000_7775\src/LCD_2000_7775.h:10:0,

                 from C:\Users\duhjoker\Desktop\Gamebuino_master\VERSIONS\ESMERELDA\ESMERELDA\ESMERELDA.ino:1:

C:\Users\duhjoker\Documents\Arduino\libraries\LCD_2000_7775\src/utility/Adafruit_GFX.h:49:5: note: void Adafruit_GFX::drawBitmap(int16_t, int16_t, const uint8_t*, int16_t, int16_t, uint16_t)

     drawBitmap(int16_t x, int16_t y, const uint8_t *bitmap,

     ^

C:\Users\duhjoker\Documents\Arduino\libraries\LCD_2000_7775\src/utility/Adafruit_GFX.h:49:5: note:   candidate expects 6 arguments, 3 provided

C:\Users\duhjoker\Documents\Arduino\libraries\LCD_2000_7775\src/utility/Adafruit_GFX.h:51:5: note: void Adafruit_GFX::drawBitmap(int16_t, int16_t, const uint8_t*, int16_t, int16_t, uint16_t, uint16_t)

     drawBitmap(int16_t x, int16_t y, const uint8_t *bitmap,

     ^

C:\Users\duhjoker\Documents\Arduino\libraries\LCD_2000_7775\src/utility/Adafruit_GFX.h:51:5: note:   candidate expects 7 arguments, 3 provided

C:\Users\duhjoker\Documents\Arduino\libraries\LCD_2000_7775\src/utility/Adafruit_GFX.h:53:5: note: void Adafruit_GFX::drawBitmap(int16_t, int16_t, uint8_t*, int16_t, int16_t, uint16_t)

     drawBitmap(int16_t x, int16_t y, uint8_t *bitmap,

     ^

C:\Users\duhjoker\Documents\Arduino\libraries\LCD_2000_7775\src/utility/Adafruit_GFX.h:53:5: note:   candidate expects 6 arguments, 3 provided

C:\Users\duhjoker\Documents\Arduino\libraries\LCD_2000_7775\src/utility/Adafruit_GFX.h:55:5: note: void Adafruit_GFX::drawBitmap(int16_t, int16_t, uint8_t*, int16_t, int16_t, uint16_t, uint16_t)

     drawBitmap(int16_t x, int16_t y, uint8_t *bitmap,

     ^

C:\Users\duhjoker\Documents\Arduino\libraries\LCD_2000_7775\src/utility/Adafruit_GFX.h:55:5: note:   candidate expects 7 arguments, 3 provided

ESMERELDA:130: error: no matching function for call to 'LCD_2000_7775::drawBitmap(int&, int&, const byte [258])'
     gb.display.drawBitmap(player_x,player_y,sever_front_1);

                                                          ^

C:\Users\duhjoker\Desktop\Gamebuino_master\VERSIONS\ESMERELDA\ESMERELDA\ESMERELDA.ino:130:58: note: candidates are:

In file included from C:\Users\duhjoker\Documents\Arduino\libraries\LCD_2000_7775\src/LCD_2000_7775.h:10:0,

                 from C:\Users\duhjoker\Desktop\Gamebuino_master\VERSIONS\ESMERELDA\ESMERELDA\ESMERELDA.ino:1:

C:\Users\duhjoker\Documents\Arduino\libraries\LCD_2000_7775\src/utility/Adafruit_GFX.h:49:5: note: void Adafruit_GFX::drawBitmap(int16_t, int16_t, const uint8_t*, int16_t, int16_t, uint16_t)

     drawBitmap(int16_t x, int16_t y, const uint8_t *bitmap,

     ^

C:\Users\duhjoker\Documents\Arduino\libraries\LCD_2000_7775\src/utility/Adafruit_GFX.h:49:5: note:   candidate expects 6 arguments, 3 provided

C:\Users\duhjoker\Documents\Arduino\libraries\LCD_2000_7775\src/utility/Adafruit_GFX.h:51:5: note: void Adafruit_GFX::drawBitmap(int16_t, int16_t, const uint8_t*, int16_t, int16_t, uint16_t, uint16_t)

     drawBitmap(int16_t x, int16_t y, const uint8_t *bitmap,

     ^

C:\Users\duhjoker\Documents\Arduino\libraries\LCD_2000_7775\src/utility/Adafruit_GFX.h:51:5: note:   candidate expects 7 arguments, 3 provided

C:\Users\duhjoker\Documents\Arduino\libraries\LCD_2000_7775\src/utility/Adafruit_GFX.h:53:5: note: void Adafruit_GFX::drawBitmap(int16_t, int16_t, uint8_t*, int16_t, int16_t, uint16_t)

     drawBitmap(int16_t x, int16_t y, uint8_t *bitmap,

     ^

C:\Users\duhjoker\Documents\Arduino\libraries\LCD_2000_7775\src/utility/Adafruit_GFX.h:53:5: note:   candidate expects 6 arguments, 3 provided

C:\Users\duhjoker\Documents\Arduino\libraries\LCD_2000_7775\src/utility/Adafruit_GFX.h:55:5: note: void Adafruit_GFX::drawBitmap(int16_t, int16_t, uint8_t*, int16_t, int16_t, uint16_t, uint16_t)

     drawBitmap(int16_t x, int16_t y, uint8_t *bitmap,

     ^

C:\Users\duhjoker\Documents\Arduino\libraries\LCD_2000_7775\src/utility/Adafruit_GFX.h:55:5: note:   candidate expects 7 arguments, 3 provided

ESMERELDA:143: error: no matching function for call to 'LCD_2000_7775::drawBitmap(int&, int&, const byte [8])'
     gb.display.drawBitmap(player_x,player_y,sever_right_1);

                                                          ^

C:\Users\duhjoker\Desktop\Gamebuino_master\VERSIONS\ESMERELDA\ESMERELDA\ESMERELDA.ino:143:58: note: candidates are:

In file included from C:\Users\duhjoker\Documents\Arduino\libraries\LCD_2000_7775\src/LCD_2000_7775.h:10:0,

                 from C:\Users\duhjoker\Desktop\Gamebuino_master\VERSIONS\ESMERELDA\ESMERELDA\ESMERELDA.ino:1:

C:\Users\duhjoker\Documents\Arduino\libraries\LCD_2000_7775\src/utility/Adafruit_GFX.h:49:5: note: void Adafruit_GFX::drawBitmap(int16_t, int16_t, const uint8_t*, int16_t, int16_t, uint16_t)

     drawBitmap(int16_t x, int16_t y, const uint8_t *bitmap,

     ^

C:\Users\duhjoker\Documents\Arduino\libraries\LCD_2000_7775\src/utility/Adafruit_GFX.h:49:5: note:   candidate expects 6 arguments, 3 provided

C:\Users\duhjoker\Documents\Arduino\libraries\LCD_2000_7775\src/utility/Adafruit_GFX.h:51:5: note: void Adafruit_GFX::drawBitmap(int16_t, int16_t, const uint8_t*, int16_t, int16_t, uint16_t, uint16_t)

     drawBitmap(int16_t x, int16_t y, const uint8_t *bitmap,

     ^

C:\Users\duhjoker\Documents\Arduino\libraries\LCD_2000_7775\src/utility/Adafruit_GFX.h:51:5: note:   candidate expects 7 arguments, 3 provided

C:\Users\duhjoker\Documents\Arduino\libraries\LCD_2000_7775\src/utility/Adafruit_GFX.h:53:5: note: void Adafruit_GFX::drawBitmap(int16_t, int16_t, uint8_t*, int16_t, int16_t, uint16_t)

     drawBitmap(int16_t x, int16_t y, uint8_t *bitmap,

     ^

C:\Users\duhjoker\Documents\Arduino\libraries\LCD_2000_7775\src/utility/Adafruit_GFX.h:53:5: note:   candidate expects 6 arguments, 3 provided

C:\Users\duhjoker\Documents\Arduino\libraries\LCD_2000_7775\src/utility/Adafruit_GFX.h:55:5: note: void Adafruit_GFX::drawBitmap(int16_t, int16_t, uint8_t*, int16_t, int16_t, uint16_t, uint16_t)

     drawBitmap(int16_t x, int16_t y, uint8_t *bitmap,

     ^

C:\Users\duhjoker\Documents\Arduino\libraries\LCD_2000_7775\src/utility/Adafruit_GFX.h:55:5: note:   candidate expects 7 arguments, 3 provided

ESMERELDA:155: error: no matching function for call to 'LCD_2000_7775::drawBitmap(int&, int&, const byte [8])'
     gb.display.drawBitmap(player_x,player_y,sever_left_1);

                                                         ^

C:\Users\duhjoker\Desktop\Gamebuino_master\VERSIONS\ESMERELDA\ESMERELDA\ESMERELDA.ino:155:57: note: candidates are:

In file included from C:\Users\duhjoker\Documents\Arduino\libraries\LCD_2000_7775\src/LCD_2000_7775.h:10:0,

                 from C:\Users\duhjoker\Desktop\Gamebuino_master\VERSIONS\ESMERELDA\ESMERELDA\ESMERELDA.ino:1:

C:\Users\duhjoker\Documents\Arduino\libraries\LCD_2000_7775\src/utility/Adafruit_GFX.h:49:5: note: void Adafruit_GFX::drawBitmap(int16_t, int16_t, const uint8_t*, int16_t, int16_t, uint16_t)

     drawBitmap(int16_t x, int16_t y, const uint8_t *bitmap,

     ^

C:\Users\duhjoker\Documents\Arduino\libraries\LCD_2000_7775\src/utility/Adafruit_GFX.h:49:5: note:   candidate expects 6 arguments, 3 provided

C:\Users\duhjoker\Documents\Arduino\libraries\LCD_2000_7775\src/utility/Adafruit_GFX.h:51:5: note: void Adafruit_GFX::drawBitmap(int16_t, int16_t, const uint8_t*, int16_t, int16_t, uint16_t, uint16_t)

     drawBitmap(int16_t x, int16_t y, const uint8_t *bitmap,

     ^

C:\Users\duhjoker\Documents\Arduino\libraries\LCD_2000_7775\src/utility/Adafruit_GFX.h:51:5: note:   candidate expects 7 arguments, 3 provided

C:\Users\duhjoker\Documents\Arduino\libraries\LCD_2000_7775\src/utility/Adafruit_GFX.h:53:5: note: void Adafruit_GFX::drawBitmap(int16_t, int16_t, uint8_t*, int16_t, int16_t, uint16_t)

     drawBitmap(int16_t x, int16_t y, uint8_t *bitmap,

     ^

C:\Users\duhjoker\Documents\Arduino\libraries\LCD_2000_7775\src/utility/Adafruit_GFX.h:53:5: note:   candidate expects 6 arguments, 3 provided

C:\Users\duhjoker\Documents\Arduino\libraries\LCD_2000_7775\src/utility/Adafruit_GFX.h:55:5: note: void Adafruit_GFX::drawBitmap(int16_t, int16_t, uint8_t*, int16_t, int16_t, uint16_t, uint16_t)

     drawBitmap(int16_t x, int16_t y, uint8_t *bitmap,

     ^

C:\Users\duhjoker\Documents\Arduino\libraries\LCD_2000_7775\src/utility/Adafruit_GFX.h:55:5: note:   candidate expects 7 arguments, 3 provided

Multiple libraries were found for "gfxfont.h"
 Used: C:\Program Files (x86)\Arduino\hardware\teensy\avr\libraries\ssd1351
 Not used: C:\Program Files (x86)\Arduino\hardware\teensy\avr\libraries\Adafruit_GFX
 Not used: C:\Program Files (x86)\Arduino\hardware\teensy\avr\libraries\Adafruit_GFX
 Not used: C:\Program Files (x86)\Arduino\hardware\teensy\avr\libraries\Adafruit_GFX
 Not used: C:\Program Files (x86)\Arduino\hardware\teensy\avr\libraries\Adafruit_GFX
use of deleted function 'Gamebuino::Gamebuino()'

This report would have more information with
"Show verbose output during compilation"
option enabled in File -> Preferences.



edited
User avatar
Duhjoker
 
Posts: 446
Joined: Sat Jul 02, 2016 4:57 am
Location: Where Palm trees grow

Next

Return to Software Development

Who is online

Users browsing this forum: No registered users and 12 guests

cron