tilemap function help

Understanding the language, error messages, etc.

tilemap function help

Postby Duhjoker » Fri Sep 30, 2016 9:05 am

Hi guys

I finally got the LCD,s display files to be compatible with the teensy's library so now I can use my screen with the teensy. YAY!

Im havinf trouble with the bitmap function in the new library. I have it placed right in my header file but I keep getting errors about a couple things in the .cpp file. First I marked out the bitmap commands in my gfx file that im not gonna use.

Any way Im just trying to compile a simple example and this is what I get.....
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"

C:\Users\duhjoker\Documents\Arduino\libraries\LCD_2000_7775_TEENSY\src\utility\Adafruit_GFX.cpp: In member function 'void Adafruit_GFX::drawTilemap(int, int, const uint8_t*, const uint8_t**, uint8_t, uint8_t, uint8_t, uint8_t)':

C:\Users\duhjoker\Documents\Arduino\libraries\LCD_2000_7775_TEENSY\src\utility\Adafruit_GFX.cpp:477:72: error: no matching function for call to 'Adafruit_GFX::drawBitmap(int8_t&, int8_t&, uint8_t&, uint8_t&, const uint8_t*&)'

     drawBitmap(drawX, drawY, tile_width, tile_height, spritesheet[tile]);

                                                                        ^

C:\Users\duhjoker\Documents\Arduino\libraries\LCD_2000_7775_TEENSY\src\utility\Adafruit_GFX.cpp:477:72: note: candidate is:

C:\Users\duhjoker\Documents\Arduino\libraries\LCD_2000_7775_TEENSY\src\utility\Adafruit_GFX.cpp:356:6: note: void Adafruit_GFX::drawBitmap(int16_t, int16_t, const uint8_t*, int16_t, int16_t, uint16_t)

 void Adafruit_GFX::drawBitmap(int16_t x, int16_t y,

      ^

C:\Users\duhjoker\Documents\Arduino\libraries\LCD_2000_7775_TEENSY\src\utility\Adafruit_GFX.cpp:356:6: note:   candidate expects 6 arguments, 5 provided

C:\Users\duhjoker\Documents\Arduino\libraries\LCD_2000_7775_TEENSY\src\utility\Adafruit_GFX.cpp:487:88: error: no matching function for call to 'Adafruit_GFX::drawBitmap(int8_t&, int8_t&, uint8_t&, uint8_t&, const uint8_t*&, uint8_t&, uint8_t&, uint8_t&, uint8_t&)'

     drawBitmap(drawX, drawY, tile_width, tile_height, spritesheet[tile], dx, dy, dw, dh);

                                                                                        ^

C:\Users\duhjoker\Documents\Arduino\libraries\LCD_2000_7775_TEENSY\src\utility\Adafruit_GFX.cpp:487:88: note: candidate is:

C:\Users\duhjoker\Documents\Arduino\libraries\LCD_2000_7775_TEENSY\src\utility\Adafruit_GFX.cpp:356:6: note: void Adafruit_GFX::drawBitmap(int16_t, int16_t, const uint8_t*, int16_t, int16_t, uint16_t)

 void Adafruit_GFX::drawBitmap(int16_t x, int16_t y,

      ^

C:\Users\duhjoker\Documents\Arduino\libraries\LCD_2000_7775_TEENSY\src\utility\Adafruit_GFX.cpp:356:6: note:   candidate expects 6 arguments, 9 provided

C:\Users\duhjoker\Documents\Arduino\libraries\LCD_2000_7775_TEENSY\src\utility\Adafruit_GFX.cpp: In member function 'void Adafruit_GFX::drawChar(int16_t, int16_t, unsigned char, uint16_t, uint16_t, uint8_t)':

C:\Users\duhjoker\Documents\Arduino\libraries\LCD_2000_7775_TEENSY\src\utility\Adafruit_GFX.cpp:590:14: warning: unused variable 'xa' [-Wunused-variable]

              xa = pgm_read_byte(&glyph->xAdvance);

              ^

Error compiling for board Teensy 3.2 / 3.1.

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


heres the gfx.cpp

Code: Select all


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

#define LCD_2000_7775_TFTWIDTH 176
#define LCD_2000_7775_TFTHEIGHT 220

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

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

 ///SUMMONER123
void Adafruit_GFX::drawTilemap(int x, int y, const uint8_t *tilemap, const uint8_t **spritesheet) {
   drawTilemap(x, y, tilemap, spritesheet, 0, 0, LCD_2000_7775_TFTWIDTH, LCD_2000_7775_TFTHEIGHT);
}
void Adafruit_GFX::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) {
   uint8_t tilemap_width = pgm_read_byte(tilemap);
   uint8_t tilemap_height = pgm_read_byte(tilemap + 1);
   uint8_t tile_width = pgm_read_byte(tilemap + 2);
   uint8_t tile_height = pgm_read_byte(tilemap + 3);
   tilemap += 4; // now the first tiyleis at tilemap
   uint8_t ddw = dw + dx;
   uint8_t ddh = dh + dy;
   uint8_t maxDdx = (dw - x + tile_width - 1) / tile_width;
   uint8_t maxDdy = (dh - y + tile_height - 1) / tile_height;
   if (tilemap_width < maxDdx) {
      maxDdx = tilemap_width;
   }
   if (tilemap_height < maxDdy) {
      maxDdy = tilemap_height;
   }
   int8_t startDdx = (-x) / tile_width;
   int8_t startDdy = (-y) / tile_height;
   if (startDdx < 0) {
      startDdx = 0;
   }
   if (startDdy < 0) {
      startDdy = 0;
   }
   if (flagcollision)numcolision = 0;                                 //Line 735 - clear numcolision - ADD by Summoner123

   for (uint8_t ddy = startDdy; ddy < maxDdy; ddy++) {
      for (uint8_t ddx = startDdx; ddx < maxDdx; ddx++) {
         int8_t drawX = ddx*tile_width + x + dx;
         int8_t drawY = ddy*tile_height + y + dy;
         uint8_t tile = pgm_read_byte(tilemap + ddy*tilemap_width + ddx);
         if (drawX >= dx && drawY >= dy && drawX <= (ddw - tile_width) && drawY <= (ddh - tile_height)) {
            drawBitmap(drawX, drawY, tile_width, tile_height, spritesheet[tile]);

            if (flagcollision) {
               solid[numcolision].x = drawX;                     //Save X coordinate      - ADD by Summoner123
               solid[numcolision].y = drawY;                     //Save Y coordinate      - ADD by Summoner123
               solid[numcolision].spritecol = spritesheet[tile]; //Save Sprite of tile    - ADD by Summoner123
               numcolision++;                                    //Increment numcolision  - ADD by Summoner123
            }
         }
         else { // we need to draw a partial bitmap
            drawBitmap(drawX, drawY, tile_width, tile_height, spritesheet[tile], dx, dy, dw, dh);
         }
      }
   }
}

#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){
  return cursor_x;
}

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

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

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

uint16_t Adafruit_GFX::newColor(uint8_t r, uint8_t g, uint8_t b)
{
   return ((r & 0xF8) << 8) | ((g & 0xFC) << 3) | (b >> 3);
}

void Adafruit_GFX::background(uint8_t red, uint8_t green, uint8_t blue)
{
   background(newColor(red, green, blue));
}

void Adafruit_GFX::background(color c) {
   fillScreen(c);
}

void Adafruit_GFX::stroke(uint8_t red, uint8_t green, uint8_t blue)
{
   stroke(newColor(red, green, blue));
}

void Adafruit_GFX::stroke(color c)
{
   useStroke = true;
   strokeColor = c;
   setTextColor(c);
}

void Adafruit_GFX::noStroke()
{
   useStroke = false;
}

void Adafruit_GFX::noFill() {
   useFill = false;
}

void Adafruit_GFX::fill(uint8_t red, uint8_t green, uint8_t blue)
{
   fill(newColor(red, green, blue));
}

void Adafruit_GFX::fill(color c)
{
   useFill = true;
   fillColor = c;
}


void Adafruit_GFX::text(const char * text, int16_t x, int16_t y)
{
   if (!useStroke)
      return;

   setTextWrap(false);
   setTextColor(strokeColor);
   setCursor(x, y);
   print(text);
}

void Adafruit_GFX::textWrap(const char * text, int16_t x, int16_t y)
{
   if (!useStroke)
      return;

   setTextWrap(true);
   setTextColor(strokeColor);
   setCursor(x, y);
   print(text);
}


void Adafruit_GFX::textSize(uint8_t size)
{
   setTextSize(size);
}

void Adafruit_GFX::point(int16_t x, int16_t y)
{
   if (!useStroke)
      return;

   drawPixel(x, y, strokeColor);
}

void Adafruit_GFX::line(int16_t x1, int16_t y1, int16_t x2, int16_t y2)
{
   if (!useStroke)
      return;

   if (x1 == x2) {
      if (y1 < y2)
         drawFastVLine(x1, y1, y2 - y1, strokeColor);
      else
         drawFastVLine(x1, y2, y1 - y2, strokeColor);
   }
   else if (y1 == y2) {
      if (x1 < x2)
         drawFastHLine(x1, y1, x2 - x1, strokeColor);
      else
         drawFastHLine(x2, y1, x1 - x2, strokeColor);
   }
   else {
      drawLine(x1, y1, x2, y2, strokeColor);
   }
}

void Adafruit_GFX::rect(int16_t x, int16_t y, int16_t width, int16_t height)
{
   if (useFill) {
      fillRect(x, y, width, height, fillColor);
   }
   if (useStroke) {
      drawRect(x, y, width, height, strokeColor);
   }
}

void Adafruit_GFX::rect(int16_t x, int16_t y, int16_t width, int16_t height, int16_t radius)
{
   if (radius == 0) {
      rect(x, y, width, height);
   }
   if (useFill) {
      fillRoundRect(x, y, width, height, radius, fillColor);
   }
   if (useStroke) {
      drawRoundRect(x, y, width, height, radius, strokeColor);
   }
}

void Adafruit_GFX::circle(int16_t x, int16_t y, int16_t r)
{
   if (r == 0)
      return;

   if (useFill) {
      fillCircle(x, y, r, fillColor);
   }
   if (useStroke) {
      drawCircle(x, y, r, strokeColor);
   }
}

void Adafruit_GFX::triangle(int16_t x1, int16_t y1, int16_t x2, int16_t y2, int16_t x3, int16_t y3)
{
   if (useFill) {
      fillTriangle(x1, y1, x2, y2, x3, y3, fillColor);
   }
   if (useStroke) {
      drawTriangle(x1, y1, x2, y2, x3, y3, strokeColor);
   }
}

/***************************************************************************/
// 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;
    }
  }
}




.h

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"

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

/* TODO
enum RectMode {
CORNER,
CORNERS,
RADIUS,
CENTER
};
*/

typedef uint16_t color;

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, //DUHJOKER
    //  int16_t w, int16_t h, uint16_t color, uint16_t bg),  //DUHJOKER
    //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,    //DUHJOKER
      //int16_t w, int16_t h, uint16_t color, uint16_t bg),  //DUHJOKER
    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

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

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

  uint8_t getRotation(void);

  // get current cursor position (get rotation safe maximum values, using: width() for x, height() for y)
  int16_t getCursorX(void);
  int16_t getCursorY(void);

  /*
  * Processing-like graphics primitives
  */

  /// transforms a color in 16-bit form given the RGB components.
  /// The default implementation makes a 5-bit red, a 6-bit
  /// green and a 5-bit blue (MSB to LSB). Devices that use
  /// different scheme should override this.
  virtual uint16_t newColor(uint8_t red, uint8_t green, uint8_t blue);


  void
     // http://processing.org/reference/background_.html
     background(uint8_t red, uint8_t green, uint8_t blue),
     background(color c),

     // http://processing.org/reference/fill_.html
     fill(uint8_t red, uint8_t green, uint8_t blue),
     fill(color c),

     // http://processing.org/reference/noFill_.html
     noFill(),

     // http://processing.org/reference/stroke_.html
     stroke(uint8_t red, uint8_t green, uint8_t blue),
     stroke(color c),

     // http://processing.org/reference/noStroke_.html
     noStroke(),

     text(const char * text, int16_t x, int16_t y),
     textWrap(const char * text, int16_t x, int16_t y),

     textSize(uint8_t size),

     // similar to ellipse() in Processing, but with
     // a single radius.
     // http://processing.org/reference/ellipse_.html
     circle(int16_t x, int16_t y, int16_t r),
     point(int16_t x, int16_t y),
     line(int16_t x1, int16_t y1, int16_t x2, int16_t y2),
     quad(int16_t x1, int16_t y1, int16_t x2, int16_t y2, int16_t x3, int16_t y3, int16_t x4, int16_t y4),
     rect(int16_t x, int16_t y, int16_t width, int16_t height),
     rect(int16_t x, int16_t y, int16_t width, int16_t height, int16_t radius),
     triangle(int16_t x1, int16_t y1, int16_t x2, int16_t y2, int16_t x3, int16_t y3);

  /* TODO
  void rectMode(RectMode mode);

  void pushStyle();
  void popStyle();
  */

 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;

  /*
  * Processing-style graphics state
  */

  color strokeColor;
  bool useStroke;
  color fillColor;
  bool useFill;

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

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



do I need to change the values the errors list? to what?
User avatar
Duhjoker
 
Posts: 446
Joined: Sat Jul 02, 2016 4:57 am
Location: Where Palm trees grow

Re: tilemap function help

Postby Duhjoker » Fri Sep 30, 2016 9:13 am

heres a sketch and the lcd files

Code: Select all
#include <LCD_2000_7775.h>

// pin definition for the Uno
#define cs   11
#define wr   10
#define rs   12
//#define le   13



#define D0    9
#define D1    8
#define D2    7
#define D3    6
#define D4    5
#define D5    4
#define D6    3
#define D7    2


// pin definition for the Leonardo
// #define cs   7
// #define dc   0
// #define rst  1

// create an instance of the library
//LCD_2000_7775 TFTscreen(cs,wr,rs,le);
LCD_2000_7775 TFTscreen(cs,wr,rs);
// char array to print to the screen
char sensorPrintout[4];

void setup() {
 
  // Put this line at the beginning of every sketch that uses the GLCD:
  TFTscreen.setdatapin(D0,D1,D2,D3,D4,D5,D6,D7);
  TFTscreen.begin();

  // clear the screen with a black background
  TFTscreen.background(0, 0, 0);
 
  // write the static text to the screen
  // set the font color to white
  TFTscreen.stroke(255,255,255);
  // set the font size
  TFTscreen.setTextSize(2);
  // write the text to the top left corner of the screen
  TFTscreen.text("Sensor Value :\n ",0,0);
  // ste the font size very large for the loop
  TFTscreen.setTextSize(5);
}

void loop() {

  // Read the value of the sensor on A0
  String sensorVal = String(analogRead(A0));
 
  // convert the reading to a char array
  sensorVal.toCharArray(sensorPrintout, 4);

  // set the font color
  TFTscreen.stroke(255,255,255);
  // print the sensor value
  TFTscreen.text(sensorPrintout, 0, 20);
  // wait for a moment
  delay(250);
  // erase the text you just wrote
  TFTscreen.stroke(0,0,0);
  TFTscreen.text(sensorPrintout, 0, 20);
}



lcd_7775.cpp

Code: Select all
#include "LCD_2000_7775.h"


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

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

LCD_2000_7775::LCD_2000_7775(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 LCD_2000_7775::write_delay()
   {   
      volatile uint32_t delaycnt = 10;
      while( delaycnt-- );
   }
#endif


void LCD_2000_7775::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 LCD_2000_7775::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 LCD_2000_7775::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 LCD_2000_7775::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 LCD_2000_7775::write_cmd(uint16_t cmd ,uint16_t data)
{
   this->write_wr_reg(cmd);
   this->write_wr_data(data);
}

void LCD_2000_7775::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 LCD_2000_7775::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 LCD_2000_7775::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 LCD_2000_7775::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 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);
}


/*********************************º¯Êý******************************/
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;
}




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


#define LCD_2000_7775_TFTWIDTH 176
#define LCD_2000_7775_TFTHEIGHT 220


class LCD_2000_7775 : public Adafruit_GFX
{
   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 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 drawbitmap(uint16_t* data, uint16_t x ,uint16_t y,uint16_t with , uint16_t height);
      
//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


Return to Programming Questions

Who is online

Users browsing this forum: No registered users and 9 guests

cron