Need help including new display files in to Gamebuino

[Duhjoker]

All right guys, I have working display files with all the Gamebuino bits but with color added for the Gamebuino advanced prototype. Now I mrwady to start trying to include the new display files with in the Gamebuino library.

I'm looking at the gb files and It looks like I can pretty much drop my new files into the Gameuino folder but I will need to rebuild the button commands since I'm using so many extra buttons. Most of the stuff in the Gamebuino library will be defunct as its already included in the LCD's source code.


So where should I start the next phase of getting the LCD to work with the Gamebuino library?

[rodot]

You should use a self-explanatory title, this one doesn't really give a hint about what you're asking. By the way, try to ask specific questions, and give context. Don't assume people have read all your previous posts. If it's in the continuity of your previous posts, then you should not create a new topic.

Even I, who followed your project, don't really know what you're asking for.
If you want people to help you, make it easy for them

[Duhjoker]

Sorry I fixed it!!!!!

Ok so I have a working display library ready to be worked into a Gamebuino library. And now I'm wondering where to start next. I know I will need help updating the Gamebuino or adding those functions to my LCD file but I have no idea where to start.

I did actually start the sound files, dropping them in my library and including them in my master file. It's giving me trouble with the channels which are located in the Gamebuino.cpp file but as always I'm a lil confused about how to place them in my .cpp the void begin() looks completely different than the Gamebuino.cpp void begin().

Hold on I will edit this from my computer to show what I'm talking about.

gamebuino.cpp void begin()

Code: Select all


oid Gamebuino::begin() {
   timePerFrame = 50;
   //nextFrameMillis = 0;
   //frameCount = 0;
   frameEndMicros = 1;
   startMenuTimer = 255;
   //read default settings from flash memory (set using settings.hex)
   readSettings();
   //init everything
   backlight.begin();
   backlight.set(BACKLIGHT_MAX);
   buttons.begin();
   buttons.update();
   battery.begin();
   display.begin(SCR_CLK, SCR_DIN, SCR_DC, SCR_CS, SCR_RST);
   sound.begin();
   
   //mute when B is held during start up
   if(buttons.pressed(BTN_B)){
      sound.setVolume(0);
   }
   else{ //play the startup sound on each channel for it to be louder
      #if(NUM_CHANNELS > 0)
         sound.playPattern(startupSound, 0);
      #endif
      #if(NUM_CHANNELS > 1)
         sound.playPattern(startupSound, 1);
      #endif
      #if(NUM_CHANNELS > 2)
         sound.playPattern(startupSound, 2);
      #endif
      #if(NUM_CHANNELS > 3)
         sound.playPattern(startupSound, 3);
      #endif
   }
}




my display files begin

Code: Select all


void LCD_2000_7775::begin()
{
      if( this->_rest )
      {
             *(this->restport) &= (~this->restpinmask);               
             delay(50); //     Delay 50ms
             *(this->restport) |= this->restpinmask;      
             delay(10); //     Delay 10ms
      }
   
      this->write_cmd(0x0001, 0x011C); // set SS and NL bit
    this->write_cmd(0x0002, 0x0100); // set 1 line inversion
    this->write_cmd(0x0003, 0x1030); // set GRAM write direction and BGR=1,??16BIT 65K?MDT1=0,MDT0=0
    this->write_cmd(0x0008, 0x0808); // set BP and FP
    this->write_cmd(0x000C, 0x0000); // RGB interface setting R0Ch=0x0110 for RGB 18Bit and R0Ch=0111for

    this->write_cmd(0x000F, 0x0e01); // Set frame rate
   
//*************Power On sequence ****************//
    delay(50); //     Delay 50ms
    this->write_cmd(0x0010, 0x0A00); // Set SAP,DSTB,STB
    this->write_cmd(0x0011, 0x1038); // Set APON,PON,AON,VCI1EN,VC
    //delay(50); //     Delay 50ms
    this->write_cmd(0x00ff, 0x0003);    //
    this->write_cmd(0x00b0, 0x1411);    //Set VCOM 1d
    this->write_cmd(0x00b1, 0x0202);    //GVCL/GVDD voltage setting
    this->write_cmd(0x00b2, 0x0313);  //VCL voltage setting

//------------------------ Set GRAM area  set window --------------------------------//
    this->write_cmd (0x0030, 0x0000);//???????
    this->write_cmd (0x0031, 0x00db);
    this->write_cmd (0x0032, 0x0000);
    this->write_cmd (0x0033, 0x0000);//??????
    this->write_cmd (0x0034, 0x00db);
    this->write_cmd (0x0035, 0x0000);//R34H,R35H???????
    this->write_cmd (0x0036, 0x00AF);
    this->write_cmd (0x0037, 0x0000);
    this->write_cmd (0x0038, 0x00DB);
    this->write_cmd (0x0039, 0x0000);
    delay(20);
   
    this->write_cmd(0x00ff, 0x0003);
//    WriteRegister(0x00b0, 0x1d01);
// ----------- Adjust the Gamma Curve ----------//
     this->write_cmd(0x0050, 0x0000);
     this->write_cmd(0x0051, 0x0300);
     this->write_cmd(0x0052, 0x0103);
     this->write_cmd(0x0053, 0x2011);
     this->write_cmd(0x0054, 0x0703);
     this->write_cmd(0x0055, 0x0000);
     this->write_cmd(0x0056, 0x0400);
     this->write_cmd(0x0057, 0x0107);
     this->write_cmd(0x0058, 0x2011);
     this->write_cmd(0x0059, 0x0703);
     delay(50); //     Delay 50ms
     this->write_cmd(0x0020, 0x0000); // Set GRAM Address
     this->write_cmd(0x0021, 0x0000); // Set GRAM Address
     this->write_cmd(0x0007, 0x1017);
   
      
      this->fillRect(0,0,LCD_2000_7775_TFTWIDTH,LCD_2000_7775_TFTHEIGHT,0xffff);
}



I think it would be easier to use just the gamebuino files instead but either way I have to add something

[rodot]

Ok, so I guess it's still about your Advanced Gamebuino Prototype or Color Display Library or LCD Screen advice topics so why create a new one ?

Here we have just no idea what you are talking about : What is you project ? What is your goal ? What is you problem ? What hardware do you use ? What library do you use ?

Also, try a bit by yourself before asking for help, I'm sure you can figure most of this out

Especially as Jonnection already answered your question here :

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

Or is your question about porting the Gamebuino sound library to a teensy ? It's not even clear.

So this is a friendly warning : please stop posting compulsively before you even try for yourself, or worse when your questions where already answered. And write clear topics with context and explicit questions so people can understand, stop creating multiple topics about the same subject and stop posting several times in a row. Thank you !

[Duhjoker]

I apologize and will keep the rest of my GBA needs and questions with in this thread and I will start doing more editing when i have a question thats in the topic. Not trying to argue With you or anything I really like the Gamebuino and I think you have an outstanding product compared to any the competition. But this a forum right? I have been encouraged from the get go to ask questions so I'm a tiny bit confused. I might solve one problem then have another.

I understand your un-ease with my project but i am truly doing this for rvery one. I'm not trying to profit from this in any way. In fact ive been more than willing to share all my work with you and the world. Im not trying to intrude at all im just adding an option.

But yes this about the Gamebuino advanced prototype. As it turns out I have 1 through 3 of jonnections list completed. I was hoping to get some advice for adapting the Gamebuino library to accept my new display library. I was playing around with the sound files but that's pretty trivial when it comes to the other stuff that's needed.

So please can I get some advice as to where or how to include the display files with in Gamebuino.h and cpp files.

Edit

Ok so I've been trying to get the new library to work with the Gamebuino files. I commented out the Includes for the for backlights and display and replaced them with defines for the new files. I also tried to change the class on my display files so they use Display instead of adafruit_gfx and LCD_2000_7775 thinking that might make things a lil easier but now I'm getting all kinds of errors.

I'm not worried about the bitmap errors just yet but I could use a lil advice on what I could be doing wrong with every thing else.

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"

In file included from C:\Users\duhjoker\Documents\Arduino\libraries\Gamebuinosummoner123/Gamebuino.h:27:0,

                 from C:\Users\duhjoker\Desktop\ESMERELDA\ESMERELDA\ESMERELDA.ino:5:

C:\Users\duhjoker\Documents\Arduino\libraries\Gamebuinosummoner123/Adafruit_GFX.h:59:36: error: ISO C++ forbids declaration of 'Adafruit_GFX' with no type [-fpermissive]

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

                                    ^

In file included from C:\Users\duhjoker\Documents\Arduino\libraries\Gamebuinosummoner123/Gamebuino.h:27:0,

                 from C:\Users\duhjoker\Desktop\ESMERELDA\ESMERELDA\ESMERELDA.ino:5:

C:\Users\duhjoker\Documents\Arduino\libraries\Gamebuinosummoner123/Adafruit_GFX.h:181:5: warning: non-static const member 'const int16_t Display::WIDTH' in class without a constructor [-Wuninitialized]

     WIDTH, HEIGHT;   // This is the 'raw' display w/h - never changes

     ^

C:\Users\duhjoker\Documents\Arduino\libraries\Gamebuinosummoner123/Adafruit_GFX.h:181:12: warning: non-static const member 'const int16_t Display::HEIGHT' in class without a constructor [-Wuninitialized]

     WIDTH, HEIGHT;   // This is the 'raw' display w/h - never changes

            ^

C:\Users\duhjoker\Documents\Arduino\libraries\Gamebuinosummoner123/Adafruit_GFX.h:238:19: error: 'Adafruit_GFX' has not been declared

   void initButton(Adafruit_GFX *gfx, int16_t x, int16_t y,

                   ^

C:\Users\duhjoker\Documents\Arduino\libraries\Gamebuinosummoner123/Adafruit_GFX.h:250:3: error: 'Adafruit_GFX' does not name a type

   Adafruit_GFX *_gfx;

   ^

C:\Users\duhjoker\Documents\Arduino\libraries\Gamebuinosummoner123/Adafruit_GFX.h:260:40: error: expected class-name before '{' token

 class GFXcanvas1 : public Adafruit_GFX {

                                        ^

C:\Users\duhjoker\Documents\Arduino\libraries\Gamebuinosummoner123/Adafruit_GFX.h:272:41: error: expected class-name before '{' token

 class GFXcanvas16 : public Adafruit_GFX {

                                         ^

In file included from C:\Users\duhjoker\Documents\Arduino\libraries\Gamebuinosummoner123/Gamebuino.h:28:0,

                 from C:\Users\duhjoker\Desktop\ESMERELDA\ESMERELDA\ESMERELDA.ino:5:

C:\Users\duhjoker\Documents\Arduino\libraries\Gamebuinosummoner123/LCD_2000_7775.h:19:7: error: redefinition of 'class Display'

 class Display: public Print

       ^

In file included from C:\Users\duhjoker\Documents\Arduino\libraries\Gamebuinosummoner123/Gamebuino.h:27:0,

                 from C:\Users\duhjoker\Desktop\ESMERELDA\ESMERELDA\ESMERELDA.ino:5:

C:\Users\duhjoker\Documents\Arduino\libraries\Gamebuinosummoner123/Adafruit_GFX.h:55:7: error: previous definition of 'class Display'

 class Display : public Print {

       ^

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

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

     Backlight backlight;

     ^

C:\Users\duhjoker\Documents\Arduino\libraries\Gamebuinosummoner123/Gamebuino.h:46:13: error: cannot declare field 'Gamebuino::display' to be of abstract type 'Display'

     Display display;

             ^

In file included from C:\Users\duhjoker\Documents\Arduino\libraries\Gamebuinosummoner123/Gamebuino.h:27:0,

                 from C:\Users\duhjoker\Desktop\ESMERELDA\ESMERELDA\ESMERELDA.ino:5:

C:\Users\duhjoker\Documents\Arduino\libraries\Gamebuinosummoner123/Adafruit_GFX.h:55:7: note:   because the following virtual functions are pure within 'Display':

 class Display : public Print {

       ^

C:\Users\duhjoker\Documents\Arduino\libraries\Gamebuinosummoner123/Adafruit_GFX.h:63:16: note:    virtual void Display::drawPixel(int16_t, int16_t, uint16_t)

   virtual void drawPixel(int16_t x, int16_t y, uint16_t color) = 0;

                ^

ESMERELDA:7: error: use of deleted function 'Gamebuino::Gamebuino()'
 Gamebuino gb;

           ^

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

C:\Users\duhjoker\Documents\Arduino\libraries\Gamebuinosummoner123/Gamebuino.h:40:7: note: 'Gamebuino::Gamebuino()' is implicitly deleted because the default definition would be ill-formed:

 class Gamebuino {

       ^

C:\Users\duhjoker\Documents\Arduino\libraries\Gamebuinosummoner123/Gamebuino.h:40:7: error: use of deleted function 'Display::Display()'

In file included from C:\Users\duhjoker\Documents\Arduino\libraries\Gamebuinosummoner123/Gamebuino.h:27:0,

                 from C:\Users\duhjoker\Desktop\ESMERELDA\ESMERELDA\ESMERELDA.ino:5:

C:\Users\duhjoker\Documents\Arduino\libraries\Gamebuinosummoner123/Adafruit_GFX.h:55:7: note: 'Display::Display()' is implicitly deleted because the default definition would be ill-formed:

 class Display : public Print {

       ^

C:\Users\duhjoker\Documents\Arduino\libraries\Gamebuinosummoner123/Adafruit_GFX.h:55:7: error: uninitialized non-static const member 'const int16_t Display::WIDTH'

C:\Users\duhjoker\Documents\Arduino\libraries\Gamebuinosummoner123/Adafruit_GFX.h:55:7: error: uninitialized non-static const member 'const int16_t Display::HEIGHT'

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

                                    ^

C:\Users\duhjoker\Desktop\ESMERELDA\ESMERELDA\ESMERELDA.ino:104:36: note: candidates are:

In file included from C:\Users\duhjoker\Documents\Arduino\libraries\Gamebuinosummoner123/Gamebuino.h:27:0,

                 from C:\Users\duhjoker\Desktop\ESMERELDA\ESMERELDA\ESMERELDA.ino:5:

C:\Users\duhjoker\Documents\Arduino\libraries\Gamebuinosummoner123/Adafruit_GFX.h:89:8: note: void Display::drawBitmap(int8_t, int8_t, const uint8_t*, uint16_t)

   void drawBitmap(int8_t x, int8_t y, const uint8_t *bitmap, uint16_t color);

        ^

C:\Users\duhjoker\Documents\Arduino\libraries\Gamebuinosummoner123/Adafruit_GFX.h:89:8: note:   candidate expects 4 arguments, 3 provided

C:\Users\duhjoker\Documents\Arduino\libraries\Gamebuinosummoner123/Adafruit_GFX.h:91:8: note: void Display::drawBitmap(int8_t, int8_t, const uint8_t*, uint8_t, uint8_t, uint16_t)

   void drawBitmap(int8_t x, int8_t y, const uint8_t *bitmap, uint8_t rotation, uint8_t flip, uint16_t color);

        ^

C:\Users\duhjoker\Documents\Arduino\libraries\Gamebuinosummoner123/Adafruit_GFX.h:91:8: note:   candidate expects 6 arguments, 3 provided

C:\Users\duhjoker\Documents\Arduino\libraries\Gamebuinosummoner123/Adafruit_GFX.h:92:8: note: void Display::drawBitmap(int8_t, int8_t, int8_t, int8_t, const uint8_t*, uint8_t, uint8_t, uint8_t, uint8_t, uint16_t)

   void drawBitmap(int8_t x, int8_t y, int8_t w, int8_t h, const uint8_t *bitmap, uint8_t dx, uint8_t dy, uint8_t dw, uint8_t dh, uint16_t color);

        ^

C:\Users\duhjoker\Documents\Arduino\libraries\Gamebuinosummoner123/Adafruit_GFX.h:92:8: note:   candidate expects 10 arguments, 3 provided

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

                                                          ^

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

In file included from C:\Users\duhjoker\Documents\Arduino\libraries\Gamebuinosummoner123/Gamebuino.h:27:0,

                 from C:\Users\duhjoker\Desktop\ESMERELDA\ESMERELDA\ESMERELDA.ino:5:

C:\Users\duhjoker\Documents\Arduino\libraries\Gamebuinosummoner123/Adafruit_GFX.h:89:8: note: void Display::drawBitmap(int8_t, int8_t, const uint8_t*, uint16_t)

   void drawBitmap(int8_t x, int8_t y, const uint8_t *bitmap, uint16_t color);

        ^

C:\Users\duhjoker\Documents\Arduino\libraries\Gamebuinosummoner123/Adafruit_GFX.h:89:8: note:   candidate expects 4 arguments, 3 provided

C:\Users\duhjoker\Documents\Arduino\libraries\Gamebuinosummoner123/Adafruit_GFX.h:91:8: note: void Display::drawBitmap(int8_t, int8_t, const uint8_t*, uint8_t, uint8_t, uint16_t)

   void drawBitmap(int8_t x, int8_t y, const uint8_t *bitmap, uint8_t rotation, uint8_t flip, uint16_t color);

        ^

C:\Users\duhjoker\Documents\Arduino\libraries\Gamebuinosummoner123/Adafruit_GFX.h:91:8: note:   candidate expects 6 arguments, 3 provided

C:\Users\duhjoker\Documents\Arduino\libraries\Gamebuinosummoner123/Adafruit_GFX.h:92:8: note: void Display::drawBitmap(int8_t, int8_t, int8_t, int8_t, const uint8_t*, uint8_t, uint8_t, uint8_t, uint8_t, uint16_t)

   void drawBitmap(int8_t x, int8_t y, int8_t w, int8_t h, const uint8_t *bitmap, uint8_t dx, uint8_t dy, uint8_t dw, uint8_t dh, uint16_t color);

        ^

C:\Users\duhjoker\Documents\Arduino\libraries\Gamebuinosummoner123/Adafruit_GFX.h:92:8: note:   candidate expects 10 arguments, 3 provided

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

                                                         ^

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

In file included from C:\Users\duhjoker\Documents\Arduino\libraries\Gamebuinosummoner123/Gamebuino.h:27:0,

                 from C:\Users\duhjoker\Desktop\ESMERELDA\ESMERELDA\ESMERELDA.ino:5:

C:\Users\duhjoker\Documents\Arduino\libraries\Gamebuinosummoner123/Adafruit_GFX.h:89:8: note: void Display::drawBitmap(int8_t, int8_t, const uint8_t*, uint16_t)

   void drawBitmap(int8_t x, int8_t y, const uint8_t *bitmap, uint16_t color);

        ^

C:\Users\duhjoker\Documents\Arduino\libraries\Gamebuinosummoner123/Adafruit_GFX.h:89:8: note:   candidate expects 4 arguments, 3 provided

C:\Users\duhjoker\Documents\Arduino\libraries\Gamebuinosummoner123/Adafruit_GFX.h:91:8: note: void Display::drawBitmap(int8_t, int8_t, const uint8_t*, uint8_t, uint8_t, uint16_t)

   void drawBitmap(int8_t x, int8_t y, const uint8_t *bitmap, uint8_t rotation, uint8_t flip, uint16_t color);

        ^

C:\Users\duhjoker\Documents\Arduino\libraries\Gamebuinosummoner123/Adafruit_GFX.h:91:8: note:   candidate expects 6 arguments, 3 provided

C:\Users\duhjoker\Documents\Arduino\libraries\Gamebuinosummoner123/Adafruit_GFX.h:92:8: note: void Display::drawBitmap(int8_t, int8_t, int8_t, int8_t, const uint8_t*, uint8_t, uint8_t, uint8_t, uint8_t, uint16_t)

   void drawBitmap(int8_t x, int8_t y, int8_t w, int8_t h, const uint8_t *bitmap, uint8_t dx, uint8_t dy, uint8_t dw, uint8_t dh, uint16_t color);

        ^

C:\Users\duhjoker\Documents\Arduino\libraries\Gamebuinosummoner123/Adafruit_GFX.h:92:8: note:   candidate expects 10 arguments, 3 provided

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

                                                          ^

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

In file included from C:\Users\duhjoker\Documents\Arduino\libraries\Gamebuinosummoner123/Gamebuino.h:27:0,

                 from C:\Users\duhjoker\Desktop\ESMERELDA\ESMERELDA\ESMERELDA.ino:5:

C:\Users\duhjoker\Documents\Arduino\libraries\Gamebuinosummoner123/Adafruit_GFX.h:89:8: note: void Display::drawBitmap(int8_t, int8_t, const uint8_t*, uint16_t)

   void drawBitmap(int8_t x, int8_t y, const uint8_t *bitmap, uint16_t color);

        ^

C:\Users\duhjoker\Documents\Arduino\libraries\Gamebuinosummoner123/Adafruit_GFX.h:89:8: note:   candidate expects 4 arguments, 3 provided

C:\Users\duhjoker\Documents\Arduino\libraries\Gamebuinosummoner123/Adafruit_GFX.h:91:8: note: void Display::drawBitmap(int8_t, int8_t, const uint8_t*, uint8_t, uint8_t, uint16_t)

   void drawBitmap(int8_t x, int8_t y, const uint8_t *bitmap, uint8_t rotation, uint8_t flip, uint16_t color);

        ^

C:\Users\duhjoker\Documents\Arduino\libraries\Gamebuinosummoner123/Adafruit_GFX.h:91:8: note:   candidate expects 6 arguments, 3 provided

C:\Users\duhjoker\Documents\Arduino\libraries\Gamebuinosummoner123/Adafruit_GFX.h:92:8: note: void Display::drawBitmap(int8_t, int8_t, int8_t, int8_t, const uint8_t*, uint8_t, uint8_t, uint8_t, uint8_t, uint16_t)

   void drawBitmap(int8_t x, int8_t y, int8_t w, int8_t h, const uint8_t *bitmap, uint8_t dx, uint8_t dy, uint8_t dw, uint8_t dh, uint16_t color);

        ^

C:\Users\duhjoker\Documents\Arduino\libraries\Gamebuinosummoner123/Adafruit_GFX.h:92:8: note:   candidate expects 10 arguments, 3 provided

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

                                                          ^

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

In file included from C:\Users\duhjoker\Documents\Arduino\libraries\Gamebuinosummoner123/Gamebuino.h:27:0,

                 from C:\Users\duhjoker\Desktop\ESMERELDA\ESMERELDA\ESMERELDA.ino:5:

C:\Users\duhjoker\Documents\Arduino\libraries\Gamebuinosummoner123/Adafruit_GFX.h:89:8: note: void Display::drawBitmap(int8_t, int8_t, const uint8_t*, uint16_t)

   void drawBitmap(int8_t x, int8_t y, const uint8_t *bitmap, uint16_t color);

        ^

C:\Users\duhjoker\Documents\Arduino\libraries\Gamebuinosummoner123/Adafruit_GFX.h:89:8: note:   candidate expects 4 arguments, 3 provided

C:\Users\duhjoker\Documents\Arduino\libraries\Gamebuinosummoner123/Adafruit_GFX.h:91:8: note: void Display::drawBitmap(int8_t, int8_t, const uint8_t*, uint8_t, uint8_t, uint16_t)

   void drawBitmap(int8_t x, int8_t y, const uint8_t *bitmap, uint8_t rotation, uint8_t flip, uint16_t color);

        ^

C:\Users\duhjoker\Documents\Arduino\libraries\Gamebuinosummoner123/Adafruit_GFX.h:91:8: note:   candidate expects 6 arguments, 3 provided

C:\Users\duhjoker\Documents\Arduino\libraries\Gamebuinosummoner123/Adafruit_GFX.h:92:8: note: void Display::drawBitmap(int8_t, int8_t, int8_t, int8_t, const uint8_t*, uint8_t, uint8_t, uint8_t, uint8_t, uint16_t)

   void drawBitmap(int8_t x, int8_t y, int8_t w, int8_t h, const uint8_t *bitmap, uint8_t dx, uint8_t dy, uint8_t dw, uint8_t dh, uint16_t color);

        ^

C:\Users\duhjoker\Documents\Arduino\libraries\Gamebuinosummoner123/Adafruit_GFX.h:92:8: note:   candidate expects 10 arguments, 3 provided

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

                                                         ^

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

In file included from C:\Users\duhjoker\Documents\Arduino\libraries\Gamebuinosummoner123/Gamebuino.h:27:0,

                 from C:\Users\duhjoker\Desktop\ESMERELDA\ESMERELDA\ESMERELDA.ino:5:

C:\Users\duhjoker\Documents\Arduino\libraries\Gamebuinosummoner123/Adafruit_GFX.h:89:8: note: void Display::drawBitmap(int8_t, int8_t, const uint8_t*, uint16_t)

   void drawBitmap(int8_t x, int8_t y, const uint8_t *bitmap, uint16_t color);

        ^

C:\Users\duhjoker\Documents\Arduino\libraries\Gamebuinosummoner123/Adafruit_GFX.h:89:8: note:   candidate expects 4 arguments, 3 provided

C:\Users\duhjoker\Documents\Arduino\libraries\Gamebuinosummoner123/Adafruit_GFX.h:91:8: note: void Display::drawBitmap(int8_t, int8_t, const uint8_t*, uint8_t, uint8_t, uint16_t)

   void drawBitmap(int8_t x, int8_t y, const uint8_t *bitmap, uint8_t rotation, uint8_t flip, uint16_t color);

        ^

C:\Users\duhjoker\Documents\Arduino\libraries\Gamebuinosummoner123/Adafruit_GFX.h:91:8: note:   candidate expects 6 arguments, 3 provided

C:\Users\duhjoker\Documents\Arduino\libraries\Gamebuinosummoner123/Adafruit_GFX.h:92:8: note: void Display::drawBitmap(int8_t, int8_t, int8_t, int8_t, const uint8_t*, uint8_t, uint8_t, uint8_t, uint8_t, uint16_t)

   void drawBitmap(int8_t x, int8_t y, int8_t w, int8_t h, const uint8_t *bitmap, uint8_t dx, uint8_t dy, uint8_t dw, uint8_t dh, uint16_t color);

        ^

C:\Users\duhjoker\Documents\Arduino\libraries\Gamebuinosummoner123/Adafruit_GFX.h:92:8: note:   candidate expects 10 arguments, 3 provided

use of deleted function 'Gamebuino::Gamebuino()'

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



my sketch

Code: Select all

Gamebuino gb;


const byte room_1[] PROGMEM = {88,48,
0x59,0x65,0x96,0x59,0x60,0x00,0x59,0x65,0x96,0x59,0x60
,0xa6,0x9a,0x69,0xa6,0x90,0x00,0xa6,0x9a,0x69,0xa6,0x90
,0x14,0x51,0x45,0x14,0x50,0x00,0x14,0x51,0x45,0x14,0x50
,0xa2,0x8a,0x28,0xa2,0x80,0x00,0xa2,0x8a,0x28,0xa2,0x80
,0x86,0x18,0x61,0x86,0x10,0x00,0x86,0x18,0x61,0x86,0x10
,0x59,0x65,0x96,0x59,0x60,0x00,0x59,0x65,0x96,0x59,0x60
,0x59,0x65,0x80,0x58,0x00,0x00,0x00,0x00,0x00,0x59,0x60
,0xa6,0x9a,0x40,0xa4,0x00,0x00,0x00,0x00,0x00,0xa6,0x90
,0x14,0x51,0x40,0x14,0x00,0x00,0x00,0x00,0x00,0x14,0x50
,0xa2,0x8a,0x00,0xa0,0x00,0x00,0x00,0x00,0x00,0xa2,0x80
,0x86,0x18,0x40,0x84,0x00,0x00,0x00,0x00,0x00,0x86,0x10
,0x59,0x65,0x80,0x58,0x00,0x00,0x00,0x00,0x00,0x59,0x60
,0x59,0x60,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x59,0x60
,0xa6,0x90,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xa6,0x90
,0x14,0x50,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x14,0x50
,0xa2,0x80,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xa2,0x80
,0x86,0x10,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x86,0x10
,0x59,0x60,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x59,0x60
,0x58,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x59,0x60
,0xa4,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xa6,0x90
,0x14,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x14,0x50
,0xa0,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xa2,0x80
,0x84,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x86,0x10
,0x58,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x59,0x60
,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
,0x59,0x60,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x59,0x60
,0xa6,0x90,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xa6,0x90
,0x14,0x50,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x14,0x50
,0xa2,0x80,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xa2,0x80
,0x86,0x10,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x86,0x10
,0x59,0x60,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x59,0x60
,0x59,0x60,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x59,0x60
,0xa6,0x90,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xa6,0x90
,0x14,0x50,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x14,0x50
,0xa2,0x80,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xa2,0x80
,0x86,0x10,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x86,0x10
,0x59,0x60,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x59,0x60
,0x59,0x65,0x96,0x59,0x65,0x96,0x59,0x65,0x96,0x59,0x60
,0xa6,0x9a,0x69,0xa6,0x9a,0x69,0xa6,0x9a,0x69,0xa6,0x90
,0x14,0x51,0x45,0x14,0x51,0x45,0x14,0x51,0x45,0x14,0x50
,0xa2,0x8a,0x28,0xa2,0x8a,0x28,0xa2,0x8a,0x28,0xa2,0x80
,0x86,0x18,0x61,0x86,0x18,0x61,0x86,0x18,0x61,0x86,0x10
,0x59,0x65,0x96,0x59,0x65,0x96,0x59,0x65,0x96,0x59,0x60,};


const byte sever_front_1[] PROGMEM = {16,16,0x00,0xff,0x00,0x00,0x00,0x07,0x07,0x07,0x07,0x07,0x00,0x00,0x00,0xff,0x00,0x00
,0x00,0xff,0xff,0xff,0x07,0x07,0x07,0x07,0x07,0x07,0x07,0xff,0xff,0xff,0x00,0x00
,0x00,0x00,0x00,0xff,0xff,0x07,0xff,0xff,0xff,0x07,0xff,0xff,0x00,0x00,0x00,0x00
,0x00,0xff,0x00,0x00,0x07,0x07,0x07,0x07,0x07,0x07,0x07,0x00,0x00,0x00,0x00,0x00
,0x00,0xff,0x00,0x07,0xf6,0x07,0xf6,0xf6,0xf6,0x07,0xf6,0x07,0x00,0x00,0x00,0x00
,0x00,0xff,0x07,0xf6,0xf6,0x07,0xf6,0xf6,0xf6,0x07,0xf6,0xf6,0x07,0x00,0x00,0x00
,0x00,0xff,0x07,0x07,0xf6,0xf6,0xf6,0x07,0xf6,0xf6,0xf6,0x07,0x07,0x07,0x07,0x00
,0x00,0xff,0x07,0xff,0x07,0x07,0xf6,0xf6,0xf6,0x07,0x07,0x07,0xff,0xff,0xff,0x07
,0x00,0xff,0x07,0xff,0xff,0x07,0x07,0x07,0x07,0x07,0x07,0xff,0x07,0x07,0x07,0xff
,0x07,0x07,0x07,0xff,0x07,0x07,0x07,0x07,0x07,0x07,0x07,0xff,0x07,0xf6,0x07,0xff
,0x07,0xf6,0xf6,0x00,0xff,0x07,0xff,0xff,0xff,0xff,0x07,0xff,0x07,0xf6,0x07,0xff
,0x07,0xf6,0xf6,0x00,0x07,0x07,0x07,0x07,0x07,0x07,0x07,0xff,0x07,0x07,0x07,0xff
,0x00,0xff,0x00,0x07,0x07,0xff,0x07,0x07,0x07,0x07,0x07,0xff,0xff,0xff,0xff,0x00
,0x00,0x00,0x00,0x07,0xff,0xff,0x07,0x07,0xff,0xff,0xff,0xff,0x00,0x00,0x00,0x00
,0x00,0x00,0x00,0xf6,0xf6,0xf6,0x00,0x00,0xf6,0xf6,0xf6,0xf6,0x00,0x00,0x00,0x00
,0x00,0x00,0x00,0x07,0x07,0x07,0x00,0x00,0x07,0x07,0x07,0x07,0x00,0x00,0x00,0x00
};
const byte sever_front_2[] PROGMEM = {8,6,0x84,0x48,0x78,0x84,0x78,0x0,};
const byte sever_left_1[] PROGMEM = {8,6,0x78,0x80,0xc8,0xb4,0x0,0xcc,};
const byte sever_left_2[] PROGMEM = {8,6,0x4,0x58,0x30,0x0,0x78,0x0,};
const byte sever_rear_1[] PROGMEM = {8,6,0X78,0X78,0X0,0X30,0X0,0XCC,};
const byte sever_rear_2[] PROGMEM = {8,6,0x84,0x0,0x78,0x84,0x78,0x0,};
const byte sever_right_1[] PROGMEM = {8,6,0x78,0x4,0x4c,0xb4,0x0,0xcc,};
const byte sever_right_2[] PROGMEM = {8,6,0x80,0x68,0x30,0x0,0x78,0x0,};

  int player_x = 15;
  int player_y = 15;
 
// the setup routine runs once when Gamebuino starts up
void setup(){
  // initialize the Gamebuino object
  gb.begin();
  //display the main menu:
  gb.titleScreen(F("Myth of ESmerelda"));
  gb.setFrameRate(80);
}

// the loop routine runs over and over again forever
void loop(){
  //updates the gamebuino (the display, the sound, the auto backlight... everything)
  //returns true when it's time to render a new frame (20 times/second)
  if(gb.update()){
    //prints Hello World! on the screen
   gb.display.drawBitmap(0,0,room_1);
 
    // gb.display.setColor(BLACK);{
    gb.display.drawBitmap(player_x,player_y,sever_front_1);
    //}
   
    //gb.display.setColor(GRAY);{
    //gb.display.drawBitmap(player_x,player_y,sever_front_2);
   
 
    if(gb.buttons.repeat(BTN_UP,1)){
       //gb.display.setColor(BLACK);{
    gb.display.drawBitmap(player_x,player_y,sever_rear_1);
    //}
    //gb.display.setColor(GRAY);{
   // gb.display.drawBitmap(player_x,player_y,sever_rear_2);
    //}
      player_y = player_y - 1;}
    if(player_y <= 0){
      player_y = 0;}
  //}
   


    if(gb.buttons.repeat(BTN_DOWN,1)){
      //gb.display.setColor(BLACK);{
    gb.display.drawBitmap(player_x,player_y,sever_front_1);
   // }
     //gb.display.setColor(GRAY);{
    //gb.display.drawBitmap(player_x,player_y,sever_front_2);
   // }
      player_y = player_y + 1;}
    if(player_y >= 40){
      player_y = 40;}

//}

    if(gb.buttons.repeat(BTN_RIGHT,1)){
       //gb.display.setColor(BLACK);{
    gb.display.drawBitmap(player_x,player_y,sever_right_1);
    //}
     //gb.display.setColor(GRAY);{
    //gb.display.drawBitmap(player_x,player_y,sever_right_2);
    }
      player_x = player_x + 1;}
    if(player_x >= 77){
      player_x = 77;}


    if(gb.buttons.repeat(BTN_LEFT,1)){
       //gb.display.setColor(BLACK);{
    gb.display.drawBitmap(player_x,player_y,sever_left_1);
    //}
    //gb.display.setColor(GRAY);{
    //gb.display.drawBitmap(player_x,player_y,sever_left_2);
    //}
      player_x = player_x - 1;}
    if(player_x <= -2){
      player_x = -2;}

  }



the modified part of the gamrbuino.h

Code: Select all

#ifndef GAMEBUINO_H
#define   GAMEBUINO_H

#include <Arduino.h>
#include <avr/pgmspace.h>
#include <avr/sleep.h>
#include "settings.c"
#include "Adafruit_GFX.h"
#include "LCD_2000_7775.h"
//#include "Backlight.h"
//#include "Display.h"
//#include "Buttons.h"
#include "Battery.h"
#include "Sound.h"

#define load_game (*((void(*)(const char* filename))(0x7ffc/2)))
#define write_flash_page (*((void(*)(const char * page, unsigned char * buffer))(0x7ffa/2)))

#define wrap(i, imax) ((imax+i)%(imax))

class Gamebuino {
public:
    //Backlight backlight;
    //Buttons buttons;
    //Battery battery;
    Sound sound;
    Display display;


if you can tell me what else to show I can but the file is larger than what can be posted.

[rodot]

This may have sound a bit harsh, but I have no un-ease about your project at all. I'm telling you that if you want clear answers, you have to ask clear questions. Now that we have a clear question, I'll do my best to give you a clear answer.

So please can I get some advice as to where or how to include the display files with in Gamebuino.h and cpp files.

You have to replace the original Display.h and Diplay.cpp with your own. You don't have to edit any other file of the Gamebuino library.

But for it to work, your Display library must have the same members and methods with the same arguments available. You can have extra methods too, that's not a problem.

Some methods are in the Gamebuino Display.h and not in Adafruit_GFX, for example bitmaps with rotation. You still have to implement them in your library for it to be compatible, but you can put a place-holder that only draw rectangles instead of bitmaps and actually implement the bitmap methods later on.

You also have to use the same #defines and variable names as the original Display.h. For example your error message tells that you refer to "WIDTH" while the Gamebuino #defines in Display.h are "LCDWIDTH" or "LCDWIDTH_NOROT" (depending on if you want it to be affected by screen rotation).

Finally, for the Gamebuino library there has no separate GFX class, everything have been merged into Display.h and Display.cpp.

Here it look like you include both the original Display.h, your display library LCD_2000_7775.h, and the Adafruit_GFX.h library.
1 - Restore Gamebuino.h so it only includes Display.h.
2 - Create your own Display.h and Display.cpp by merging LCD_2000_7775.h/cpp and Adafruit_GFX.h/cpp.
3 - Once it compiles correctly out of the Gamebuino library, rename the variables, methods and #defines so they match thoses from the original Display.h and Display.cpp. Then check that it still compiles.
4 - Only then, replace the original Display.h and Display.cpp with yours. The Gamebuino Library should compile properly as it can call the exact same methods with the same arguments.

[Duhjoker]

Thank you Rodot. I sincerely apologize for any mis-givings on my part and will try to do as you asked as possible. I would really like to work with you in any way. I can be a lil hardheaded though. Any way.....

Seriously thank you!!! I now have a plan. Hopefully joining 4 files into two won't be so hard. I had never thought about joining them I was just busy trying to get the LCD file to work with the teensy's GFX file then trying to add them. Gonna be a really long piece of library that's for sure. I'm looking at both pairs of files now and it looks like it would be easier to add the 7775 files to the GFX.

Ok I'm gonna be editing this post with problems or solutions til I can't any more so please check back often.

Again thank you

[rodot]

Just to be sure it's clear :
LCD_2000_7775.h + Adafruit_GFX.h => Display.h
LCD_2000_7775.cpp + Adafruit_GFX.comm => Display.cpp

Actually another way that could be easier would be to update the original Display.h and Display.cpp with your LCD_2000_7775 library. The Adafruit_GFX library won't add anything that's not already in the original Display files. The main functions that you will have to update to work with a new screen are the hardware-dependent ones : init, draw pixel to name a few.

The Gamebuino library was initially based on the Adafruit library, I should have kept the hardware files separate... I can't recall why I merged these. I probably didn't think people would make Gamebuino clones back then ^^

[Duhjoker]

ok so ive been busy joining the two .cpp and .h files into a single .cpp and a single .h file. took me a while but I think I have it. does it matter the location of functions in the .cpp or do they just need to define that matching function from the h file? im still curious about the constructor dilly at the top of the .h file and its definition in the .cpp. I named them TFT for now til I can figure out what that means. I also went ahead and changed the class in the file to display as im used to writing the functions that way in the sketch.

ok heres the deal I changed the class to display but the unmodified sketch uses TFTscreen.drawBitmap() as the command structure. ive looked and I cant find a definition that says TFTscreen anywhere in the code except the sketch. how can I change that to display.drawBitmap(). if I ca figure that out I think I can continue.

heres the lcd.h

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>

#include "gfxfont.h"
#include "glcdfont.c"



#define LCD_2000_7775_TFTWIDTH 176
#define LCD_2000_7775_TFTHEIGHT 220


class Display : public print
{
   public:

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

      LCD(uint8_t cs,uint8_t wr ,uint8_t rs , uint8_t rest ,uint8_t pmw );
      LCD(uint8_t cs,uint8_t wr ,uint8_t rs , uint8_t rest );
      LCD(uint8_t cs,uint8_t wr ,uint8_t rs );
      //LCD_2000_7775(){};
      void write_spi(const uint8_t data);
      void drawPixel(int16_t x, int16_t y, uint16_t color); = 0; //gfx
      void setdatapin(uint8_t b0,uint8_t b1, uint8_t b2 , uint8_t b3, uint8_t b4, uint8_t b5, uint8_t b6, uint8_t b7);
      
      void setbracklight(uint8_t pmw);
      
      void begin();

      /////from gfx
      void drawLine(int16_t x0, int16_t y0, int16_t x1, int16_t y1, uint16_t color);
      void drawFastVLine(int16_t x, int16_t y, int16_t h, uint16_t color);
      void drawFastHLine(int16_t x, int16_t y, int16_t w, uint16_t color);
      void drawRect(int16_t x, int16_t y, int16_t w, int16_t h, uint16_t color);
      void fillRect(int16_t x, int16_t y, int16_t w, int16_t h, uint16_t color);
      void fillScreen(uint16_t color);
      invertDisplay(boolean i);

      void drawCircle(int16_t x0, int16_t y0, int16_t r, uint16_t color);
      void drawCircleHelper(int16_t x0, int16_t y0, int16_t r, uint8_t cornername, uint16_t color);
      void fillCircle(int16_t x0, int16_t y0, int16_t r, uint16_t color);
      void fillCircleHelper(int16_t x0, int16_t y0, int16_t r, uint8_t cornername, int16_t delta, uint16_t color);
      
      void drawTriangle(int16_t x0, int16_t y0, int16_t x1, int16_t y1, int16_t x2, int16_t y2, uint16_t color);
      void fillTriangle(int16_t x0, int16_t y0, int16_t x1, int16_t y1, int16_t x2, int16_t y2, uint16_t color);
      
      void drawRoundRect(int16_t x0, int16_t y0, int16_t w, int16_t h, int16_t radius, uint16_t color);
      void fillRoundRect(int16_t x0, int16_t y0, int16_t w, int16_t h, int16_t radius, uint16_t color);
      
        // from gamebuino display.h
      //void drawBitmap(int8_t x, int8_t y, const uint8_t *bitmap);
      //void drawBitmap(int8_t x, int8_t y, int8_t w, int8_t h, const uint8_t *bitmap);
      //void drawBitmap(int8_t x, int8_t y, const uint8_t *bitmap, uint8_t rotation, uint8_t flip);
      //void drawBitmap(int8_t x, int8_t y, int8_t w, int8_t h, const uint8_t *bitmap, uint8_t dx, uint8_t dy, uint8_t dw, uint8_t dh);
      
       /////from gfx
      void drawBitmap(int16_t x, int16_t y, const uint8_t *bitmap, int16_t w, int16_t h, uint16_t color);
      void drawBitmap(int16_t x, int16_t y, const uint8_t *bitmap, int16_t w, int16_t h, uint16_t color, uint16_t bg);
      void drawBitmap(int16_t x, int16_t y, uint8_t *bitmap, int16_t w, int16_t h, uint16_t color);
      void drawBitmap(int16_t x, int16_t y, uint8_t *bitmap, int16_t w, int16_t h, uint16_t color, uint16_t bg);
      boolean getBitmapPixel(const uint8_t* bitmap, uint8_t x, uint8_t y);
      
      //DRAW X-BITMAP
      void drawXBitmap(int16_t x, int16_t y, const uint8_t *bitmap, int16_t w, int16_t h, uint16_t color);

      /////from display.h
      void drawTilemap(int x, int y, const uint8_t *tilemap, const uint8_t **spritesheet);
      void drawTilemap(int x, int y, const uint8_t *tilemap, const uint8_t **spritesheet, uint8_t dx, uint8_t dy, uint8_t dw, uint8_t dh);

      /////from gfx
      void drawChar(int16_t x, int16_t y, unsigned char c, uint16_t color, uint16_t bg, uint8_t size);
      void setCursor(int16_t x, int16_t y);
      void setTextColor(uint16_t c);
      void setTextColor(uint16_t c, uint16_t bg);
      void setTextSize(uint8_t s);
      void setTextWrap(boolean w);
      void setRotation(uint8_t r);
      void cp437(boolean x = true);
      void setFont(const GFXfont *f = NULL);
      void getTextBounds(char *string, int16_t x, int16_t y, int16_t *x1, int16_t *y1, uint16_t *w, uint16_t *h);
      void getTextBounds(const __FlashStringHelper *s, int16_t x, int16_t y, int16_t *x1, int16_t *y1, uint16_t *w, uint16_t *h);

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

      int16_t height(void) const;
      int16_t width(void) const;

      uint8_t getRotation(void) const;

      // get current cursor position (get rotation safe maximum values, using: width() for x, height() for y)
      int16_t getCursorX(void) const;
      int16_t getCursorY(void) const;
      
   protected:
   const int16_t
      WIDTH, HEIGHT;   // This is the 'raw' display w/h - never changes
   int16_t
      _width, _height, // Display w/h as modified by current rotation
      cursor_x, cursor_y;
   uint16_t
      textcolor, textbgcolor;
   uint8_t
      textsize,
      rotation;
   boolean
      wrap,   // If set, 'wrap' text at right edge of display
      _cp437; // If set, use correct CP437 charset (default is off)
   GFXfont
      *gfxFont;

   boolean persistence; //disable clean() at each frame if true
   //boolean textWrap; // If set, 'wrap' text at right edge of
   uint8_t fontSize;
   int8_t cursorX, cursorY;
   byte contrast;
   byte frameCount;

   typedef struct {       //line 171 "Public Variables   - ADD by Summoner123
      int x;                    //X coordinate                 - ADD by Summoner123
      int y;                    //Y coordinate                 - ADD by Summoner123
      const byte *spritecol;    //Sprite of object             - ADD by Summoner123
   }object;
   object solid[60];         // Matriz were saved a Sprite, X and Y cordinates of all tiles on the screen - ADD by Summoner123

   byte numcolision = 0;     //count of solid objects indacat how many tiles drawed on the screen - ADD by Summoner123

   bool flagcollision = true;

}; //

//fuction
   private:
      void set_window(uint8_t x1,uint8_t y1,uint8_t x2,uint8_t y2);
      void write_wr_reg(uint16_t data);
      void write_wr_data(uint16_t data);
      void write_cmd(uint16_t cmd ,uint16_t data);
      #if 0 //defined(ARDUINO_ARCH_SAM)
         void write_delay();
      #else
         #define write_delay() 
      #endif
      
//value   
   //private:
   
   #if defined(ARDUINO_ARCH_SAM)
      uint32_t _cs;
      uint32_t _pmw;
      uint32_t _wr;
      uint32_t _rs;
      uint32_t _rest;
      
      volatile uint32_t *csport;
      volatile uint32_t *pmwport;
      volatile uint32_t *wrport;
      volatile uint32_t *rsport;
      volatile uint32_t *restport;
      
      uint32_t cspinmask;
      uint32_t pmwpinmask;
      uint32_t wrpinmask;
      uint32_t rspinmask;
      uint32_t restpinmask;
      
      volatile uint32_t data[8];
      volatile uint32_t datapinmask[8];
      volatile uint32_t* dataport[8];   
         
   #else
      uint8_t _cs;
      uint8_t _pmw;
      uint8_t _wr;
      uint8_t _rs;
      uint8_t _rest;
      
      volatile uint8_t *csport;
      volatile uint8_t *pmwport;
      volatile uint8_t *wrport;
      volatile uint8_t *rsport;
      volatile uint8_t *restport;
      
      uint8_t cspinmask;
      uint8_t pmwpinmask;
      uint8_t wrpinmask;
      uint8_t rspinmask;
      uint8_t restpinmask;
      
      volatile uint8_t data[8];
      volatile uint8_t datapinmask[8];
      volatile uint8_t* dataport[8];
   
   #endif
};

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

#endif


heres the .cpp

Code: Select all


#include "LCD_2000_7775.h"

#ifdef __AVR__
 #include <avr/pgmspace.h>
#elif defined(ESP8266)
 #include <pgmspace.h>
#endif
#include "Adafruit_GFX.h"
#include "glcdfont.c"

// Many (but maybe not all) non-AVR board installs define macros
// for compatibility with existing PROGMEM-reading AVR code.
// Do our own checks and defines here for good measure...

#ifndef pgm_read_byte
 #define pgm_read_byte(addr) (*(const unsigned char *)(addr))
#endif
#ifndef pgm_read_word
 #define pgm_read_word(addr) (*(const unsigned short *)(addr))
#endif
#ifndef pgm_read_dword
 #define pgm_read_dword(addr) (*(const unsigned long *)(addr))
#endif

// Pointers are a peculiar case...typically 16-bit on AVR boards,
// 32 bits elsewhere.  Try to accommodate both...

#if !defined(__INT_MAX__) || (__INT_MAX__ > 0xFFFF)
 #define pgm_read_pointer(addr) ((void *)pgm_read_dword(addr))
#else
 #define pgm_read_pointer(addr) ((void *)pgm_read_word(addr))
#endif

#ifndef min
#define min(a,b) (((a) < (b)) ? (a) : (b))
#endif

#ifndef _swap_int16_t
#define _swap_int16_t(a, b) { int16_t t = a; a = b; b = t; }
#endif

Display::TFT(int16_t w, int16_t h):
  WIDTH(w), HEIGHT(h)
{
  _width    = WIDTH;
  _height   = HEIGHT;
  rotation  = 0;
  cursor_y  = cursor_x    = 0;
  textsize  = 1;
  textcolor = textbgcolor = 0xFFFF;
  wrap      = true;
  _cp437    = false;
  gfxFont   = NULL;
}



Display::LCD(uint8_t cs,uint8_t wr ,uint8_t rs , uint8_t rest ,uint8_t pmw)
   : Adafruit_GFX(176, 220)
{
   this->_cs = cs;
   //this->_rd = rd;
   this->_wr = wr;
   this->_rs = rs;
   this->_rest = rest;
   this->_pmw = pmw;
   
   pinMode(this->_cs,OUTPUT);
   //pinMode(this->_rd,OUTPUT);
   pinMode(this->_wr,OUTPUT);
   pinMode(this->_rs,OUTPUT);
   pinMode(this->_rest,OUTPUT);
   pinMode(this->_pmw,OUTPUT);
   
   
   this->csport = portOutputRegister(digitalPinToPort(this->_cs));
   //this->pmwport = portOutputRegister(digitalPinToPort(this->_pmw));
   this->wrport = portOutputRegister(digitalPinToPort(this->_wr));
   this->rsport = portOutputRegister(digitalPinToPort(this->_rs));
   this->restport = portOutputRegister(digitalPinToPort(this->_rest));
   
   
   this->cspinmask  = digitalPinToBitMask(this->_cs);
   //this->pmwpinmask  = digitalPinToBitMask(this->_pmw);
   this->wrpinmask  = digitalPinToBitMask(this->_wr);
   this->rspinmask  = digitalPinToBitMask(this->_rs);
   this->restpinmask  = digitalPinToBitMask(this->_rest);
   
   *(this->csport) |= this->cspinmask;
   //*(this->pmwport) |= this->pmwpinmask;
   *(this->wrport) |= this->wrpinmask;
   *(this->rsport) |= this->rspinmask;
   *(this->restport) |= this->restpinmask;      
}

  Display::LCD(uint8_t cs,uint8_t wr ,uint8_t rs , uint8_t rest )
   : Adafruit_GFX(176, 220)
{
   this->_cs = cs;
   //this->_rd = rd;
   this->_wr = wr;
   this->_rs = rs;
   this->_rest = rest;
   
   pinMode(this->_cs,OUTPUT);
   //pinMode(this->_rd,OUTPUT);
   pinMode(this->_wr,OUTPUT);
   pinMode(this->_rs,OUTPUT);
   pinMode(this->_rest,OUTPUT);
   
   
   this->csport = portOutputRegister(digitalPinToPort(this->_cs));
   this->wrport = portOutputRegister(digitalPinToPort(this->_wr));
   this->rsport = portOutputRegister(digitalPinToPort(this->_rs));
   this->restport = portOutputRegister(digitalPinToPort(this->_rest));
      
   this->cspinmask  = digitalPinToBitMask(this->_cs);
   this->wrpinmask  = digitalPinToBitMask(this->_wr);
   this->rspinmask  = digitalPinToBitMask(this->_rs);
   this->restpinmask  = digitalPinToBitMask(this->_rest);
   
   *(this->csport) |= this->cspinmask;
   *(this->wrport) |= this->wrpinmask;
   *(this->rsport) |= this->rspinmask;
   *(this->restport) |= this->restpinmask;      
}

   Display::LCD(uint8_t cs,uint8_t wr ,uint8_t rs)
   : Adafruit_GFX(176, 220)
{
   this->_cs = cs;
   this->_wr = wr;
   this->_rs = rs;
   this->_rest = 0;
   
   pinMode(this->_cs,OUTPUT);
   pinMode(this->_wr,OUTPUT);
   pinMode(this->_rs,OUTPUT);
   
   this->csport = portOutputRegister(digitalPinToPort(this->_cs));
   this->wrport = portOutputRegister(digitalPinToPort(this->_wr));
   this->rsport = portOutputRegister(digitalPinToPort(this->_rs));
      
   this->cspinmask  = digitalPinToBitMask(this->_cs);
   this->wrpinmask  = digitalPinToBitMask(this->_wr);
   this->rspinmask  = digitalPinToBitMask(this->_rs);
   
   *(this->csport) |= this->cspinmask;
   *(this->wrport) |= this->wrpinmask;
   *(this->rsport) |= this->rspinmask;
}


#if 0 //defined(ARDUINO_ARCH_SAM)
   void Display::write_delay()
   {   
      volatile uint32_t delaycnt = 10;
      while( delaycnt-- );
   }
#endif


void Display::write_spi(const uint8_t data)
{
   uint8_t bit,i;
   for(bit = 0x01,i = 0 ; bit ; i++,bit <<= 1)   
   {
      if(data & bit) *(this->dataport[i]) |= this->datapinmask[i];
    else   *(this->dataport[i]) &= (~this->datapinmask[i]);
       
    //write_delay();
  }
}

void Display::setdatapin(uint8_t b0,uint8_t b1, uint8_t b2 , uint8_t b3,
                                       uint8_t b4, uint8_t b5, uint8_t b6, uint8_t b7)
{
   uint8_t i;
   this->data[0] = b0;
   this->data[1] = b1;
   this->data[2] = b2;
   this->data[3] = b3;
   this->data[4] = b4;
   this->data[5] = b5;
   this->data[6] = b6;
   this->data[7] = b7;
   for(i = 0; i < 8 ;i++)
      pinMode(this->data[i],OUTPUT);
   for(i = 0; i < 8 ;i++)
      dataport[i] = portOutputRegister(digitalPinToPort(this->data[i]));
   for(i = 0; i < 8 ;i++)
      datapinmask[i] = digitalPinToBitMask(this->data[i]);
   
   this->setbracklight(255);
}

void Display::write_wr_reg(uint16_t data)
{
    
    *(this->rsport) &= (~this->rspinmask);
    write_delay();
    *(this->csport) &= (~this->cspinmask);
    write_delay();
    this->write_spi( data >> 8 );
    write_delay();
    *(this->wrport) &= (~this->wrpinmask);
    write_delay();    
   *(this->wrport) |= this->wrpinmask;
    write_delay();
    this->write_spi( (data&0x00ff) );
    write_delay();
    *(this->wrport) &= (~this->wrpinmask);
    write_delay();
   *(this->wrport) |= this->wrpinmask;
   write_delay();
    *(this->csport) |= this->cspinmask;
    write_delay();
}

void Display::write_wr_data(uint16_t data)
{
   *(this->rsport) |= this->rspinmask;
   write_delay();
   *(this->csport) &= (~this->cspinmask);
   write_delay();
   
   this->write_spi( data >> 8 );
   write_delay();
   *(this->wrport) &= (~this->wrpinmask);
   write_delay();
   *(this->wrport) |= this->wrpinmask;
   write_delay();
   
   this->write_spi( (data&0x00ff) );
   write_delay();
   *(this->wrport) &= (~this->wrpinmask);
   write_delay();
   *(this->wrport) |= this->wrpinmask;
   write_delay();
   
   *(this->csport) |= this->cspinmask;
   write_delay();
}

void Display::write_cmd(uint16_t cmd ,uint16_t data)
{
   this->write_wr_reg(cmd);
   this->write_wr_data(data);
}

void Display::set_window(uint8_t x1,uint8_t y1,uint8_t x2,uint8_t y2)
{
   this->write_wr_reg(0x0037);this->write_wr_data(x1); // windows address
   this->write_wr_reg(0x0036);this->write_wr_data(x2);
   this->write_wr_reg(0x0039);this->write_wr_data(y1);   
   this->write_wr_reg(0x0038);this->write_wr_data(y2);   
   this->write_wr_reg(0x0020);  //HS
   this->write_wr_data(x1);       
   this->write_wr_reg(0x0021);  //VS
   this->write_wr_data(y1);
}

void Display::drawPixel(int16_t x, int16_t y, uint16_t color)
{
   set_window(x,y,x,y);
   //this->write_wr_reg(0x0022);
   //this->write_wr_data(color);
   this->write_cmd(0x22,color);
}

void Display::fillRect(int16_t x, int16_t y, int16_t w, int16_t h,
      uint16_t color)
{
   set_window(x,y,x+w-1,y+h-1);
   this->write_wr_reg(0x22);
   int i = w*h;
   while(i--)
      this->write_wr_data(color);
}

void Display::setbracklight(uint8_t pmw)
{
   analogWrite(this->_pmw,pmw);
}

//void  LCD_2000_7775::drawbitmap(uint16_t* data, uint16_t x ,uint16_t y,uint16_t with , uint16_t height)
//{
//   uint32_t i;
//   this->set_window(x,y,x+with-1,y+height-1);
//   this->write_wr_reg(0x22);
//   i = with * height;
//   while(i--)
//   {
//      this->write_wr_data(*data);
//      data++;
//   }
//   
//}

void Display::begin()
{
      if( this->_rest )
      {
             *(this->restport) &= (~this->restpinmask);               
             delay(50); //     Delay 50ms
             *(this->restport) |= this->restpinmask;      
             delay(10); //     Delay 10ms
      }
   
      this->write_cmd(0x0001, 0x011C); // set SS and NL bit
    this->write_cmd(0x0002, 0x0100); // set 1 line inversion
    this->write_cmd(0x0003, 0x1030); // set GRAM write direction and BGR=1,??16BIT 65K?MDT1=0,MDT0=0
    this->write_cmd(0x0008, 0x0808); // set BP and FP
    this->write_cmd(0x000C, 0x0000); // RGB interface setting R0Ch=0x0110 for RGB 18Bit and R0Ch=0111for

    this->write_cmd(0x000F, 0x0e01); // Set frame rate
   
//*************Power On sequence ****************//
    delay(50); //     Delay 50ms
    this->write_cmd(0x0010, 0x0A00); // Set SAP,DSTB,STB
    this->write_cmd(0x0011, 0x1038); // Set APON,PON,AON,VCI1EN,VC
    //delay(50); //     Delay 50ms
    this->write_cmd(0x00ff, 0x0003);    //
    this->write_cmd(0x00b0, 0x1411);    //Set VCOM 1d
    this->write_cmd(0x00b1, 0x0202);    //GVCL/GVDD voltage setting
    this->write_cmd(0x00b2, 0x0313);  //VCL voltage setting

//------------------------ Set GRAM area  set window --------------------------------//
    this->write_cmd (0x0030, 0x0000);//???????
    this->write_cmd (0x0031, 0x00db);
    this->write_cmd (0x0032, 0x0000);
    this->write_cmd (0x0033, 0x0000);//??????
    this->write_cmd (0x0034, 0x00db);
    this->write_cmd (0x0035, 0x0000);//R34H,R35H???????
    this->write_cmd (0x0036, 0x00AF);
    this->write_cmd (0x0037, 0x0000);
    this->write_cmd (0x0038, 0x00DB);
    this->write_cmd (0x0039, 0x0000);
    delay(20);
   
    this->write_cmd(0x00ff, 0x0003);
//    WriteRegister(0x00b0, 0x1d01);
// ----------- Adjust the Gamma Curve ----------//
     this->write_cmd(0x0050, 0x0000);
     this->write_cmd(0x0051, 0x0300);
     this->write_cmd(0x0052, 0x0103);
     this->write_cmd(0x0053, 0x2011);
     this->write_cmd(0x0054, 0x0703);
     this->write_cmd(0x0055, 0x0000);
     this->write_cmd(0x0056, 0x0400);
     this->write_cmd(0x0057, 0x0107);
     this->write_cmd(0x0058, 0x2011);
     this->write_cmd(0x0059, 0x0703);
     delay(50); //     Delay 50ms
     this->write_cmd(0x0020, 0x0000); // Set GRAM Address
     this->write_cmd(0x0021, 0x0000); // Set GRAM Address
     this->write_cmd(0x0007, 0x1017);
   
      
      this->fillRect(0,0,LCD_2000_7775_TFTWIDTH,LCD_2000_7775_TFTHEIGHT,0xffff);
}

// Bresenham's algorithm - thx wikpedia
void Display::drawLine(int16_t x0, int16_t y0, int16_t x1, int16_t y1,
   uint16_t color) {
   int16_t steep = abs(y1 - y0) > abs(x1 - x0);
   if (steep) {
      _swap_int16_t(x0, y0);
      _swap_int16_t(x1, y1);
   }

   if (x0 > x1) {
      _swap_int16_t(x0, x1);
      _swap_int16_t(y0, y1);
   }

   int16_t dx, dy;
   dx = x1 - x0;
   dy = abs(y1 - y0);

   int16_t err = dx / 2;
   int16_t ystep;

   if (y0 < y1) {
      ystep = 1;
   }
   else {
      ystep = -1;
   }

   for (; x0 <= x1; x0++) {
      if (steep) {
         drawPixel(y0, x0, color);
      }
      else {
         drawPixel(x0, y0, color);
      }
      err -= dy;
      if (err < 0) {
         y0 += ystep;
         err += dx;
      }
   }
}

void Display::drawFastVLine(int16_t x, int16_t y,
   int16_t h, uint16_t color) {
   // Update in subclasses if desired!
   drawLine(x, y, x, y + h - 1, color);
}

void Display::drawFastHLine(int16_t x, int16_t y,
   int16_t w, uint16_t color) {
   // Update in subclasses if desired!
   drawLine(x, y, x + w - 1, y, color);
}


// Draw a rectangle
void Display::drawRect(int16_t x, int16_t y, int16_t w, int16_t h,
   uint16_t color) {
   drawFastHLine(x, y, w, color);
   drawFastHLine(x, y + h - 1, w, color);
   drawFastVLine(x, y, h, color);
   drawFastVLine(x + w - 1, y, h, color);
}

void Display::fillRect(int16_t x, int16_t y, int16_t w, int16_t h,
   uint16_t color) {
   // Update in subclasses if desired!
   for (int16_t i = x; i<x + w; i++) {
      drawFastVLine(i, y, h, color);
   }
}

void Display::fillScreen(uint16_t color) {
   fillRect(0, 0, _width, _height, color);
}

// Draw a circle outline
void Display::drawCircle(int16_t x0, int16_t y0, int16_t r,
   uint16_t color) {
   int16_t f = 1 - r;
   int16_t ddF_x = 1;
   int16_t ddF_y = -2 * r;
   int16_t x = 0;
   int16_t y = r;

   drawPixel(x0, y0 + r, color);
   drawPixel(x0, y0 - r, color);
   drawPixel(x0 + r, y0, color);
   drawPixel(x0 - r, y0, color);

   while (x<y) {
      if (f >= 0) {
         y--;
         ddF_y += 2;
         f += ddF_y;
      }
      x++;
      ddF_x += 2;
      f += ddF_x;

      drawPixel(x0 + x, y0 + y, color);
      drawPixel(x0 - x, y0 + y, color);
      drawPixel(x0 + x, y0 - y, color);
      drawPixel(x0 - x, y0 - y, color);
      drawPixel(x0 + y, y0 + x, color);
      drawPixel(x0 - y, y0 + x, color);
      drawPixel(x0 + y, y0 - x, color);
      drawPixel(x0 - y, y0 - x, color);
   }
}

void Display::drawCircleHelper(int16_t x0, int16_t y0,
   int16_t r, uint8_t cornername, uint16_t color) {
   int16_t f = 1 - r;
   int16_t ddF_x = 1;
   int16_t ddF_y = -2 * r;
   int16_t x = 0;
   int16_t y = r;

   while (x<y) {
      if (f >= 0) {
         y--;
         ddF_y += 2;
         f += ddF_y;
      }
      x++;
      ddF_x += 2;
      f += ddF_x;
      if (cornername & 0x4) {
         drawPixel(x0 + x, y0 + y, color);
         drawPixel(x0 + y, y0 + x, color);
      }
      if (cornername & 0x2) {
         drawPixel(x0 + x, y0 - y, color);
         drawPixel(x0 + y, y0 - x, color);
      }
      if (cornername & 0x8) {
         drawPixel(x0 - y, y0 + x, color);
         drawPixel(x0 - x, y0 + y, color);
      }
      if (cornername & 0x1) {
         drawPixel(x0 - y, y0 - x, color);
         drawPixel(x0 - x, y0 - y, color);
      }
   }
}

void Display::fillCircle(int16_t x0, int16_t y0, int16_t r,
   uint16_t color) {
   drawFastVLine(x0, y0 - r, 2 * r + 1, color);
   fillCircleHelper(x0, y0, r, 3, 0, color);
}

// Used to do circles and roundrects
void Display::fillCircleHelper(int16_t x0, int16_t y0, int16_t r,
   uint8_t cornername, int16_t delta, uint16_t color) {

   int16_t f = 1 - r;
   int16_t ddF_x = 1;
   int16_t ddF_y = -2 * r;
   int16_t x = 0;
   int16_t y = r;

   while (x<y) {
      if (f >= 0) {
         y--;
         ddF_y += 2;
         f += ddF_y;
      }
      x++;
      ddF_x += 2;
      f += ddF_x;

      if (cornername & 0x1) {
         drawFastVLine(x0 + x, y0 - y, 2 * y + 1 + delta, color);
         drawFastVLine(x0 + y, y0 - x, 2 * x + 1 + delta, color);
      }
      if (cornername & 0x2) {
         drawFastVLine(x0 - x, y0 - y, 2 * y + 1 + delta, color);
         drawFastVLine(x0 - y, y0 - x, 2 * x + 1 + delta, color);
      }
   }
}


// Draw a triangle
void Display::drawTriangle(int16_t x0, int16_t y0,
   int16_t x1, int16_t y1, int16_t x2, int16_t y2, uint16_t color) {
   drawLine(x0, y0, x1, y1, color);
   drawLine(x1, y1, x2, y2, color);
   drawLine(x2, y2, x0, y0, color);
}

// Fill a triangle
void Display::fillTriangle(int16_t x0, int16_t y0,
   int16_t x1, int16_t y1, int16_t x2, int16_t y2, uint16_t color) {

   int16_t a, b, y, last;

   // Sort coordinates by Y order (y2 >= y1 >= y0)
   if (y0 > y1) {
      _swap_int16_t(y0, y1); _swap_int16_t(x0, x1);
   }
   if (y1 > y2) {
      _swap_int16_t(y2, y1); _swap_int16_t(x2, x1);
   }
   if (y0 > y1) {
      _swap_int16_t(y0, y1); _swap_int16_t(x0, x1);
   }

   if (y0 == y2) { // Handle awkward all-on-same-line case as its own thing
      a = b = x0;
      if (x1 < a)      a = x1;
      else if (x1 > b) b = x1;
      if (x2 < a)      a = x2;
      else if (x2 > b) b = x2;
      drawFastHLine(a, y0, b - a + 1, color);
      return;
   }

   int16_t
      dx01 = x1 - x0,
      dy01 = y1 - y0,
      dx02 = x2 - x0,
      dy02 = y2 - y0,
      dx12 = x2 - x1,
      dy12 = y2 - y1;
   int32_t
      sa = 0,
      sb = 0;

   // For upper part of triangle, find scanline crossings for segments
   // 0-1 and 0-2.  If y1=y2 (flat-bottomed triangle), the scanline y1
   // is included here (and second loop will be skipped, avoiding a /0
   // error there), otherwise scanline y1 is skipped here and handled
   // in the second loop...which also avoids a /0 error here if y0=y1
   // (flat-topped triangle).
   if (y1 == y2) last = y1;   // Include y1 scanline
   else         last = y1 - 1; // Skip it

   for (y = y0; y <= last; y++) {
      a = x0 + sa / dy01;
      b = x0 + sb / dy02;
      sa += dx01;
      sb += dx02;
      /* longhand:
      a = x0 + (x1 - x0) * (y - y0) / (y1 - y0);
      b = x0 + (x2 - x0) * (y - y0) / (y2 - y0);
      */
      if (a > b) _swap_int16_t(a, b);
      drawFastHLine(a, y, b - a + 1, color);
   }

   // For lower part of triangle, find scanline crossings for segments
   // 0-2 and 1-2.  This loop is skipped if y1=y2.
   sa = dx12 * (y - y1);
   sb = dx02 * (y - y0);
   for (; y <= y2; y++) {
      a = x1 + sa / dy12;
      b = x0 + sb / dy02;
      sa += dx12;
      sb += dx02;
      /* longhand:
      a = x1 + (x2 - x1) * (y - y1) / (y2 - y1);
      b = x0 + (x2 - x0) * (y - y0) / (y2 - y0);
      */
      if (a > b) _swap_int16_t(a, b);
      drawFastHLine(a, y, b - a + 1, color);
   }
}

// Draw a rounded rectangle
void Display::drawRoundRect(int16_t x, int16_t y, int16_t w,
   int16_t h, int16_t r, uint16_t color) {
   // smarter version
   drawFastHLine(x + r, y, w - 2 * r, color); // Top
   drawFastHLine(x + r, y + h - 1, w - 2 * r, color); // Bottom
   drawFastVLine(x, y + r, h - 2 * r, color); // Left
   drawFastVLine(x + w - 1, y + r, h - 2 * r, color); // Right
                                          // draw four corners
   drawCircleHelper(x + r, y + r, r, 1, color);
   drawCircleHelper(x + w - r - 1, y + r, r, 2, color);
   drawCircleHelper(x + w - r - 1, y + h - r - 1, r, 4, color);
   drawCircleHelper(x + r, y + h - r - 1, r, 8, color);
}

// Fill a rounded rectangle
void Display::fillRoundRect(int16_t x, int16_t y, int16_t w,
   int16_t h, int16_t r, uint16_t color) {
   // smarter version
   fillRect(x + r, y, w - 2 * r, h, color);

   // draw four corners
   fillCircleHelper(x + w - r - 1, y + r, r, 1, h - 2 * r - 1, color);
   fillCircleHelper(x + r, y + r, r, 2, h - 2 * r - 1, color);
}

// Draw a 1-bit image (bitmap) at the specified (x,y) position from the
// provided bitmap buffer (must be PROGMEM memory) using the specified
// foreground color (unset bits are transparent).
void Display::drawBitmap(int16_t x, int16_t y,
   const uint8_t *bitmap, int16_t w, int16_t h, uint16_t color) {

   int16_t i, j, byteWidth = (w + 7) / 8;
   uint8_t byte;

   for (j = 0; j<h; j++) {
      for (i = 0; i<w; i++) {
         if (i & 7) byte <<= 1;
         else      byte = pgm_read_byte(bitmap + j * byteWidth + i / 8);
         if (byte & 0x80) drawPixel(x + i, y + j, color);
      }
   }
}

// Draw a 1-bit image (bitmap) at the specified (x,y) position from the
// provided bitmap buffer (must be PROGMEM memory) using the specified
// foreground (for set bits) and background (for clear bits) colors.
void Display::drawBitmap(int16_t x, int16_t y,
   const uint8_t *bitmap, int16_t w, int16_t h, uint16_t color, uint16_t bg) {

   int16_t i, j, byteWidth = (w + 7) / 8;
   uint8_t byte;

   for (j = 0; j<h; j++) {
      for (i = 0; i<w; i++) {
         if (i & 7) byte <<= 1;
         else      byte = pgm_read_byte(bitmap + j * byteWidth + i / 8);
         if (byte & 0x80) drawPixel(x + i, y + j, color);
         else            drawPixel(x + i, y + j, bg);
      }
   }
}

// drawBitmap() variant for RAM-resident (not PROGMEM) bitmaps.
void Display::drawBitmap(int16_t x, int16_t y,
   uint8_t *bitmap, int16_t w, int16_t h, uint16_t color) {

   int16_t i, j, byteWidth = (w + 7) / 8;
   uint8_t byte;

   for (j = 0; j<h; j++) {
      for (i = 0; i<w; i++) {
         if (i & 7) byte <<= 1;
         else      byte = bitmap[j * byteWidth + i / 8];
         if (byte & 0x80) drawPixel(x + i, y + j, color);
      }
   }
}

// drawBitmap() variant w/background for RAM-resident (not PROGMEM) bitmaps.
void Display::drawBitmap(int16_t x, int16_t y,
   uint8_t *bitmap, int16_t w, int16_t h, uint16_t color, uint16_t bg) {

   int16_t i, j, byteWidth = (w + 7) / 8;
   uint8_t byte;

   for (j = 0; j<h; j++) {
      for (i = 0; i<w; i++) {
         if (i & 7) byte <<= 1;
         else      byte = bitmap[j * byteWidth + i / 8];
         if (byte & 0x80) drawPixel(x + i, y + j, color);
         else            drawPixel(x + i, y + j, bg);
      }
   }
}

// Draw a 1-bit image (bitmap) at the specified (x,y) position from the
// provided bitmap buffer (must be PROGMEM memory) using the specified
// foreground color (unset bits are transparent).
void Display::drawBitmap(int16_t x, int16_t y,
   const uint8_t *bitmap, int16_t w, int16_t h, uint16_t color) {

   int16_t i, j, byteWidth = (w + 7) / 8;
   uint8_t byte;

   for (j = 0; j<h; j++) {
      for (i = 0; i<w; i++) {
         if (i & 7) byte <<= 1;
         else      byte = pgm_read_byte(bitmap + j * byteWidth + i / 8);
         if (byte & 0x80) drawPixel(x + i, y + j, color);
      }
   }
}

// Draw a 1-bit image (bitmap) at the specified (x,y) position from the
// provided bitmap buffer (must be PROGMEM memory) using the specified
// foreground (for set bits) and background (for clear bits) colors.
void Display::drawBitmap(int16_t x, int16_t y,
   const uint8_t *bitmap, int16_t w, int16_t h, uint16_t color, uint16_t bg) {

   int16_t i, j, byteWidth = (w + 7) / 8;
   uint8_t byte;

   for (j = 0; j<h; j++) {
      for (i = 0; i<w; i++) {
         if (i & 7) byte <<= 1;
         else      byte = pgm_read_byte(bitmap + j * byteWidth + i / 8);
         if (byte & 0x80) drawPixel(x + i, y + j, color);
         else            drawPixel(x + i, y + j, bg);
      }
   }
}

// drawBitmap() variant for RAM-resident (not PROGMEM) bitmaps.
void Display::drawBitmap(int16_t x, int16_t y,
   uint8_t *bitmap, int16_t w, int16_t h, uint16_t color) {

   int16_t i, j, byteWidth = (w + 7) / 8;
   uint8_t byte;

   for (j = 0; j<h; j++) {
      for (i = 0; i<w; i++) {
         if (i & 7) byte <<= 1;
         else      byte = bitmap[j * byteWidth + i / 8];
         if (byte & 0x80) drawPixel(x + i, y + j, color);
      }
   }
}

// drawBitmap() variant w/background for RAM-resident (not PROGMEM) bitmaps.
void Display::drawBitmap(int16_t x, int16_t y,
   uint8_t *bitmap, int16_t w, int16_t h, uint16_t color, uint16_t bg) {

   int16_t i, j, byteWidth = (w + 7) / 8;
   uint8_t byte;

   for (j = 0; j<h; j++) {
      for (i = 0; i<w; i++) {
         if (i & 7) byte <<= 1;
         else      byte = bitmap[j * byteWidth + i / 8];
         if (byte & 0x80) drawPixel(x + i, y + j, color);
         else            drawPixel(x + i, y + j, bg);
      }
   }
}

//Draw XBitMap Files (*.xbm), exported from GIMP,
//Usage: Export from GIMP to *.xbm, rename *.xbm to *.c and open in editor.
//C Array can be directly used with this function
void Display::drawXBitmap(int16_t x, int16_t y,
   const uint8_t *bitmap, int16_t w, int16_t h, uint16_t color) {

   int16_t i, j, byteWidth = (w + 7) / 8;
   uint8_t byte;

   for (j = 0; j<h; j++) {
      for (i = 0; i<w; i++) {
         if (i & 7) byte >>= 1;
         else      byte = pgm_read_byte(bitmap + j * byteWidth + i / 8);
         if (byte & 0x01) drawPixel(x + i, y + j, color);
      }
   }
}

#if ARDUINO >= 100
size_t Display::write(uint8_t c) {
#else
void Display::write(uint8_t c) {
#endif

   if (!gfxFont) { // 'Classic' built-in font

      if (c == '\n') {
         cursor_y += textsize * 8;
         cursor_x = 0;
      }
      else if (c == '\r') {
         // skip em
      }
      else {
         if (wrap && ((cursor_x + textsize * 6) >= _width)) { // Heading off edge?
            cursor_x = 0;            // Reset x to zero
            cursor_y += textsize * 8; // Advance y one line
         }
         drawChar(cursor_x, cursor_y, c, textcolor, textbgcolor, textsize);
         cursor_x += textsize * 6;
      }

   }
   else { // Custom font

      if (c == '\n') {
         cursor_x = 0;
         cursor_y += (int16_t)textsize *
            (uint8_t)pgm_read_byte(&gfxFont->yAdvance);
      }
      else if (c != '\r') {
         uint8_t first = pgm_read_byte(&gfxFont->first);
         if ((c >= first) && (c <= (uint8_t)pgm_read_byte(&gfxFont->last))) {
            uint8_t   c2 = c - pgm_read_byte(&gfxFont->first);
            GFXglyph *glyph = &(((GFXglyph *)pgm_read_pointer(&gfxFont->glyph))[c2]);
            uint8_t   w = pgm_read_byte(&glyph->width),
               h = pgm_read_byte(&glyph->height);
            if ((w > 0) && (h > 0)) { // Is there an associated bitmap?
               int16_t xo = (int8_t)pgm_read_byte(&glyph->xOffset); // sic
               if (wrap && ((cursor_x + textsize * (xo + w)) >= _width)) {
                  // Drawing character would go off right edge; wrap to new line
                  cursor_x = 0;
                  cursor_y += (int16_t)textsize *
                     (uint8_t)pgm_read_byte(&gfxFont->yAdvance);
               }
               drawChar(cursor_x, cursor_y, c, textcolor, textbgcolor, textsize);
            }
            cursor_x += pgm_read_byte(&glyph->xAdvance) * (int16_t)textsize;
         }
      }

   }
#if ARDUINO >= 100
   return 1;
#endif
}

// Draw a character
void Display::drawChar(int16_t x, int16_t y, unsigned char c,
   uint16_t color, uint16_t bg, uint8_t size) {

   if (!gfxFont) { // 'Classic' built-in font

      if ((x >= _width) || // Clip right
         (y >= _height) || // Clip bottom
         ((x + 6 * size - 1) < 0) || // Clip left
         ((y + 8 * size - 1) < 0))   // Clip top
         return;

      if (!_cp437 && (c >= 176)) c++; // Handle 'classic' charset behavior

      for (int8_t i = 0; i<6; i++) {
         uint8_t line;
         if (i < 5) line = pgm_read_byte(font + (c * 5) + i);
         else      line = 0x0;
         for (int8_t j = 0; j<8; j++, line >>= 1) {
            if (line & 0x1) {
               if (size == 1) drawPixel(x + i, y + j, color);
               else          fillRect(x + (i*size), y + (j*size), size, size, color);
            }
            else if (bg != color) {
               if (size == 1) drawPixel(x + i, y + j, bg);
               else          fillRect(x + i*size, y + j*size, size, size, bg);
            }
         }
      }

   }
   else { // Custom font

         // Character is assumed previously filtered by write() to eliminate
         // newlines, returns, non-printable characters, etc.  Calling drawChar()
         // directly with 'bad' characters of font may cause mayhem!

      c -= pgm_read_byte(&gfxFont->first);
      GFXglyph *glyph = &(((GFXglyph *)pgm_read_pointer(&gfxFont->glyph))[c]);
      uint8_t  *bitmap = (uint8_t *)pgm_read_pointer(&gfxFont->bitmap);

      uint16_t bo = pgm_read_word(&glyph->bitmapOffset);
      uint8_t  w = pgm_read_byte(&glyph->width),
         h = pgm_read_byte(&glyph->height),
         xa = pgm_read_byte(&glyph->xAdvance);
      int8_t   xo = pgm_read_byte(&glyph->xOffset),
         yo = pgm_read_byte(&glyph->yOffset);
      uint8_t  xx, yy, bits, bit = 0;
      int16_t  xo16, yo16;

      if (size > 1) {
         xo16 = xo;
         yo16 = yo;
      }

      // Todo: Add character clipping here

      // NOTE: THERE IS NO 'BACKGROUND' COLOR OPTION ON CUSTOM FONTS.
      // THIS IS ON PURPOSE AND BY DESIGN.  The background color feature
      // has typically been used with the 'classic' font to overwrite old
      // screen contents with new data.  This ONLY works because the
      // characters are a uniform size; it's not a sensible thing to do with
      // proportionally-spaced fonts with glyphs of varying sizes (and that
      // may overlap).  To replace previously-drawn text when using a custom
      // font, use the getTextBounds() function to determine the smallest
      // rectangle encompassing a string, erase the area with fillRect(),
      // then draw new text.  This WILL infortunately 'blink' the text, but
      // is unavoidable.  Drawing 'background' pixels will NOT fix this,
      // only creates a new set of problems.  Have an idea to work around
      // this (a canvas object type for MCUs that can afford the RAM and
      // displays supporting setAddrWindow() and pushColors()), but haven't
      // implemented this yet.

      for (yy = 0; yy<h; yy++) {
         for (xx = 0; xx<w; xx++) {
            if (!(bit++ & 7)) {
               bits = pgm_read_byte(&bitmap[bo++]);
            }
            if (bits & 0x80) {
               if (size == 1) {
                  drawPixel(x + xo + xx, y + yo + yy, color);
               }
               else {
                  fillRect(x + (xo16 + xx)*size, y + (yo16 + yy)*size, size, size, color);
               }
            }
            bits <<= 1;
         }
      }

   } // End classic vs custom font
}

void Display::setCursor(int16_t x, int16_t y) {
   cursor_x = x;
   cursor_y = y;
}

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

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

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

void Display::setTextColor(uint16_t c) {
   // For 'transparent' background, we'll set the bg
   // to the same as fg instead of using a flag
   textcolor = textbgcolor = c;
}

void Display::setTextColor(uint16_t c, uint16_t b) {
   textcolor = c;
   textbgcolor = b;
}

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

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

void Display::setRotation(uint8_t x) {
   rotation = (x & 3);
   switch (rotation) {
   case 0:
   case 2:
      _width = WIDTH;
      _height = HEIGHT;
      break;
   case 1:
   case 3:
      _width = HEIGHT;
      _height = WIDTH;
      break;
   }
}

// Enable (or disable) Code Page 437-compatible charset.
// There was an error in glcdfont.c for the longest time -- one character
// (#176, the 'light shade' block) was missing -- this threw off the index
// of every character that followed it.  But a TON of code has been written
// with the erroneous character indices.  By default, the library uses the
// original 'wrong' behavior and old sketches will still work.  Pass 'true'
// to this function to use correct CP437 character values in your code.
void Display::cp437(boolean x) {
   _cp437 = x;
}

void Display::setFont(const GFXfont *f) {
   if (f) {          // Font struct pointer passed in?
      if (!gfxFont) { // And no current font struct?
                  // Switching from classic to new font behavior.
                  // Move cursor pos down 6 pixels so it's on baseline.
         cursor_y += 6;
      }
   }
   else if (gfxFont) { // NULL passed.  Current font struct defined?
                  // Switching from new to classic font behavior.
                  // Move cursor pos up 6 pixels so it's at top-left of char.
      cursor_y -= 6;
   }
   gfxFont = (GFXfont *)f;
}

// Pass string and a cursor position, returns UL corner and W,H.
void Display::getTextBounds(char *str, int16_t x, int16_t y,
   int16_t *x1, int16_t *y1, uint16_t *w, uint16_t *h) {
   uint8_t c; // Current character

   *x1 = x;
   *y1 = y;
   *w = *h = 0;

   if (gfxFont) {

      GFXglyph *glyph;
      uint8_t   first = pgm_read_byte(&gfxFont->first),
         last = pgm_read_byte(&gfxFont->last),
         gw, gh, xa;
      int8_t    xo, yo;
      int16_t   minx = _width, miny = _height, maxx = -1, maxy = -1,
         gx1, gy1, gx2, gy2, ts = (int16_t)textsize,
         ya = ts * (uint8_t)pgm_read_byte(&gfxFont->yAdvance);

      while ((c = *str++)) {
         if (c != '\n') { // Not a newline
            if (c != '\r') { // Not a carriage return, is normal char
               if ((c >= first) && (c <= last)) { // Char present in current font
                  c -= first;
                  glyph = &(((GFXglyph *)pgm_read_pointer(&gfxFont->glyph))[c]);
                  gw = pgm_read_byte(&glyph->width);
                  gh = pgm_read_byte(&glyph->height);
                  xa = pgm_read_byte(&glyph->xAdvance);
                  xo = pgm_read_byte(&glyph->xOffset);
                  yo = pgm_read_byte(&glyph->yOffset);
                  if (wrap && ((x + (((int16_t)xo + gw) * ts)) >= _width)) {
                     // Line wrap
                     x = 0;  // Reset x to 0
                     y += ya; // Advance y by 1 line
                  }
                  gx1 = x + xo * ts;
                  gy1 = y + yo * ts;
                  gx2 = gx1 + gw * ts - 1;
                  gy2 = gy1 + gh * ts - 1;
                  if (gx1 < minx) minx = gx1;
                  if (gy1 < miny) miny = gy1;
                  if (gx2 > maxx) maxx = gx2;
                  if (gy2 > maxy) maxy = gy2;
                  x += xa * ts;
               }
            } // Carriage return = do nothing
         }
         else { // Newline
            x = 0;  // Reset x
            y += ya; // Advance y by 1 line
         }
      }
      // End of string
      *x1 = minx;
      *y1 = miny;
      if (maxx >= minx) *w = maxx - minx + 1;
      if (maxy >= miny) *h = maxy - miny + 1;

   }
   else { // Default font

      uint16_t lineWidth = 0, maxWidth = 0; // Width of current, all lines

      while ((c = *str++)) {
         if (c != '\n') { // Not a newline
            if (c != '\r') { // Not a carriage return, is normal char
               if (wrap && ((x + textsize * 6) >= _width)) {
                  x = 0;            // Reset x to 0
                  y += textsize * 8; // Advance y by 1 line
                  if (lineWidth > maxWidth) maxWidth = lineWidth; // Save widest line
                  lineWidth = textsize * 6; // First char on new line
               }
               else { // No line wrap, just keep incrementing X
                  lineWidth += textsize * 6; // Includes interchar x gap
               }
            } // Carriage return = do nothing
         }
         else { // Newline
            x = 0;            // Reset x to 0
            y += textsize * 8; // Advance y by 1 line
            if (lineWidth > maxWidth) maxWidth = lineWidth; // Save widest line
            lineWidth = 0;     // Reset lineWidth for new line
         }
      }
      // End of string
      if (lineWidth) y += textsize * 8; // Add height of last (or only) line
      *w = maxWidth - 1;               // Don't include last interchar x gap
      *h = y - *y1;

   } // End classic vs custom font
}

// Same as above, but for PROGMEM strings
void Display::getTextBounds(const __FlashStringHelper *str,
   int16_t x, int16_t y, int16_t *x1, int16_t *y1, uint16_t *w, uint16_t *h) {
   uint8_t *s = (uint8_t *)str, c;

   *x1 = x;
   *y1 = y;
   *w = *h = 0;

   if (gfxFont) {

      GFXglyph *glyph;
      uint8_t   first = pgm_read_byte(&gfxFont->first),
         last = pgm_read_byte(&gfxFont->last),
         gw, gh, xa;
      int8_t    xo, yo;
      int16_t   minx = _width, miny = _height, maxx = -1, maxy = -1,
         gx1, gy1, gx2, gy2, ts = (int16_t)textsize,
         ya = ts * (uint8_t)pgm_read_byte(&gfxFont->yAdvance);

      while ((c = pgm_read_byte(s++))) {
         if (c != '\n') { // Not a newline
            if (c != '\r') { // Not a carriage return, is normal char
               if ((c >= first) && (c <= last)) { // Char present in current font
                  c -= first;
                  glyph = &(((GFXglyph *)pgm_read_pointer(&gfxFont->glyph))[c]);
                  gw = pgm_read_byte(&glyph->width);
                  gh = pgm_read_byte(&glyph->height);
                  xa = pgm_read_byte(&glyph->xAdvance);
                  xo = pgm_read_byte(&glyph->xOffset);
                  yo = pgm_read_byte(&glyph->yOffset);
                  if (wrap && ((x + (((int16_t)xo + gw) * ts)) >= _width)) {
                     // Line wrap
                     x = 0;  // Reset x to 0
                     y += ya; // Advance y by 1 line
                  }
                  gx1 = x + xo * ts;
                  gy1 = y + yo * ts;
                  gx2 = gx1 + gw * ts - 1;
                  gy2 = gy1 + gh * ts - 1;
                  if (gx1 < minx) minx = gx1;
                  if (gy1 < miny) miny = gy1;
                  if (gx2 > maxx) maxx = gx2;
                  if (gy2 > maxy) maxy = gy2;
                  x += xa * ts;
               }
            } // Carriage return = do nothing
         }
         else { // Newline
            x = 0;  // Reset x
            y += ya; // Advance y by 1 line
         }
      }
      // End of string
      *x1 = minx;
      *y1 = miny;
      if (maxx >= minx) *w = maxx - minx + 1;
      if (maxy >= miny) *h = maxy - miny + 1;

   }
   else { // Default font

      uint16_t lineWidth = 0, maxWidth = 0; // Width of current, all lines

      while ((c = pgm_read_byte(s++))) {
         if (c != '\n') { // Not a newline
            if (c != '\r') { // Not a carriage return, is normal char
               if (wrap && ((x + textsize * 6) >= _width)) {
                  x = 0;            // Reset x to 0
                  y += textsize * 8; // Advance y by 1 line
                  if (lineWidth > maxWidth) maxWidth = lineWidth; // Save widest line
                  lineWidth = textsize * 6; // First char on new line
               }
               else { // No line wrap, just keep incrementing X
                  lineWidth += textsize * 6; // Includes interchar x gap
               }
            } // Carriage return = do nothing
         }
         else { // Newline
            x = 0;            // Reset x to 0
            y += textsize * 8; // Advance y by 1 line
            if (lineWidth > maxWidth) maxWidth = lineWidth; // Save widest line
            lineWidth = 0;     // Reset lineWidth for new line
         }
      }
      // End of string
      if (lineWidth) y += textsize * 8; // Add height of last (or only) line
      *w = maxWidth - 1;               // Don't include last interchar x gap
      *h = y - *y1;

   } // End classic vs custom font
}

// Return the size of the display (per current rotation)
int16_t Display::width(void) const {
   return _width;
}

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

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

/*********************************º¯Êý******************************/
uint16_t RGB(uint16_t r,uint16_t g , uint16_t b)
{
   uint16_t rgb = 0;
   r *= 31;
   r /= 255;
   
   g *= 63;
   g /= 255;
   
   b *= 31;
   b /= 255;
   
   rgb |= (r<<11);
   rgb |= (g<<6);
   rgb |= b;
   return rgb;
}


I can move this up a post if needed.

would you mind looking it over

[rodot]

Usually your .h contains the prototypes of your classes methods, and the .cpp all the implementations. The order in the .cpp doesn't matter. You may want to read the Arduino Library Tutorial.

Sometimes though you have to implement the functions directly in the header so they can be inlined for speed optimization, for example the drawPixel in our case. But you shouldn't care about that yet.

"Display" is the name of your class in the library. "TFTscreen" or "display" is the name of your object, an instantiation of the class that you usually declare and instantiate in your sketch. When you call TFTscreen.drawBitmap() or display.drawBitmap() in your sketch, you use the name you game when you declared the object, because you call the function for this object, this specific instantiation of the class.

So in your sketch you have to change from

Code: Select all

Display TFTscreen;

to

Code: Select all

Display display;