Li Weiyi
work fine
Embed:
(wiki syntax)
Show/hide line numbers
Microduino_Matrix.cpp
00001 // 本作品采用知识共享 署名-非商业性使用-相同方式共享 3.0 未本地化版本 许可协议进行许可 00002 // 访问 http://creativecommons.org/licenses/by-nc-sa/3.0/ 查看该许可协议 00003 // ============== 00004 00005 // 版权所有： 00006 // @老潘orz wasdpkj@hotmail.com 00007 // ============== 00008 00009 // Microduino-IDE 00010 // ============== 00011 // Microduino Getting start: 00012 // http://www.microduino.cc/download/ 00013 00014 // Microduino IDE Support： 00015 // https://github.com/wasdpkj/Microduino-IDE-Support/ 00016 00017 // ============== 00018 // Microduino wiki: 00019 // http://wiki.microduino.cc 00020 00021 // ============== 00022 // E-mail: 00023 // Kejia Pan 00024 // pankejia@microduino.cc 00025 00026 // ============== 00027 // Weibo: 00028 // @老潘orz 00029 00030 #include "Microduino_Matrix.h" 00031 #include "Fonts.h" 00032 00033 extern Serial pc; 00034 00035 #define read16(Y,Z) (uint16_t)((uint8_t)pgm_read_byte((Y) + (Z++)) | ((uint8_t)pgm_read_byte((Y) + (Z++)) << 8)) 00036 #define read32(Y,Z) (uint32_t)((uint8_t)pgm_read_byte((Y) + (Z++)) | ((uint8_t)pgm_read_byte((Y) + (Z++)) << 8) | ((uint8_t)pgm_read_byte((Y) + (Z++)) << 16) | ((uint8_t)pgm_read_byte((Y) + (Z++)) << 24)) 00037 #define BUFFPIXEL (MatrixPix_X * 8 * 3) 00038 00039 Matrix::Matrix(uint8_t (*_addr)[8]) 00040 { 00041 // uint8_t (*p)[10]=_addr; 00042 uint8_t _x = 0, _y = 0; 00043 for (uint8_t a = 0; a < 8; a++) { //判断第一层 00044 if (_addr[0][a] == 0) { 00045 00046 break; //NULL，结束当前层判断 00047 } else { 00048 _x = a + 1; 00049 for (uint8_t b = 0; b < 8; b++) { //判断第二层 00050 if (_addr[b][a] == 0) { 00051 break; //NULL，结束当前层判断 00052 } else { 00053 _y = b + 1; 00054 } 00055 } 00056 } 00057 } 00058 00059 this->_numX = _x; 00060 this->_numY = _y; 00061 00062 this->_matrixNum = this->_numX * this->_numY; 00063 led = new LedControl[this->_matrixNum]; 00064 00065 this->cursor_y = 0; 00066 this->cursor_x = 0; 00067 00068 uint8_t _p[64]; 00069 for (int a = 0; a < this->_numY; a++) { 00070 for (int b = 0; b < this->_numX ; b++) { 00071 uint8_t _s = b + a * this->_numX ; 00072 _p[_s] = _addr[a][b]; 00073 } 00074 } 00075 setDeviceAddr(_p); 00076 00077 clearFastMode(); 00078 clearColor(); 00079 setFontMode(true); 00080 } 00081 00082 uint8_t Matrix::getDeviceAddr(uint8_t _a) 00083 { 00084 return led[_a].getDeviceAddr(); 00085 } 00086 00087 void Matrix::setDeviceAddr(uint8_t* _addr) 00088 { 00089 for (int a = 0; a < getMatrixNum(); a++) 00090 led[a].setDeviceAddr(_addr[a]); 00091 } 00092 00093 void Matrix::clearDisplay() 00094 { 00095 for (int a = 0; a < getMatrixNum(); a++) 00096 led[a].clearDisplay(); 00097 } 00098 00099 void Matrix::setLedColor(uint8_t _row, uint8_t _col, uint8_t _value_r, uint8_t _value_g, uint8_t _value_b) 00100 { 00101 if((_col > (getHeight() * 8 - 1)) || (_row > (getWidth() * 8 - 1))) 00102 return; 00103 int16_t _s = (_row / 8) + (_col / 8) * getWidth(); 00104 led[_s].setLedColor(_row % 8, _col % 8, _value_r, _value_g, _value_b); 00105 } 00106 00107 void Matrix::setLedColorFast(uint8_t _row, uint8_t _col, uint8_t _value_r, uint8_t _value_g, uint8_t _value_b) 00108 { 00109 if((_col > (getHeight() * 8 - 1)) || (_row > (getWidth() * 8 - 1))) 00110 return; 00111 int16_t _s = (_row / 8) + (_col / 8) * getWidth(); 00112 led[_s].setLedColorFast(_row % 8, _col % 8, _value_r, _value_g, _value_b); 00113 } 00114 00115 void Matrix::setLed(uint8_t _row, uint8_t _col, bool _state) 00116 { 00117 if((_col > (getHeight() * 8 - 1)) || (_row > (getWidth() * 8 - 1))) 00118 return; 00119 int16_t _s = (_row / 8) + (_col / 8) * getWidth(); 00120 led[_s].setLed(_row % 8, _col % 8, _state); 00121 } 00122 00123 void Matrix::setCursor(int16_t _x, int16_t _y) 00124 { 00125 this->cursor_x = _x; 00126 this->cursor_y = _y; 00127 00128 for (int _y = 0; _y < getHeight(); _y++) { 00129 for (int _x = 0; _x < getWidth(); _x++) { 00130 uint8_t _s = _x + _y * getWidth(); 00131 led[_s].setCursor(-(8 * _x) + this->cursor_x, -(8 * _y) + this->cursor_y); 00132 } 00133 } 00134 } 00135 00136 void Matrix::setFastMode() 00137 { 00138 // runFun(&setFastMode); 00139 // this->Fast_mode = true; 00140 for (int a = 0; a < getMatrixNum(); a++) 00141 led[a].setFastMode(); 00142 } 00143 00144 void Matrix::clearFastMode() 00145 { 00146 // this->Fast_mode = false; 00147 for (int a = 0; a < getMatrixNum(); a++) 00148 led[a].clearFastMode(); 00149 } 00150 00151 void Matrix::setFontMode(bool _Mode) 00152 { 00153 for (int a = 0; a < getMatrixNum(); a++) 00154 led[a].setFontMode(_Mode); 00155 } 00156 00157 void Matrix::setColor(uint8_t value_r, uint8_t value_g, uint8_t value_b) 00158 { 00159 for (int a = 0; a < getMatrixNum(); a++) 00160 led[a].setColor(value_r, value_g, value_b); 00161 } 00162 00163 void Matrix::clearColor() 00164 { 00165 for (int a = 0; a < getMatrixNum(); a++) 00166 led[a].clearColor(); 00167 } 00168 00169 void Matrix::drawLine(int8_t x1, int8_t y1, int8_t x2, int8_t y2) 00170 { 00171 uint8_t tmp; 00172 uint8_t x, y; 00173 uint8_t dx, dy; 00174 int8_t err; 00175 int8_t ystep; 00176 00177 uint8_t swapxy = 0; 00178 00179 /* no BBX intersection check at the moment, should be added... */ 00180 00181 if ( x1 > x2 ) dx = x1 - x2; 00182 else dx = x2 - x1; 00183 if ( y1 > y2 ) dy = y1 - y2; 00184 else dy = y2 - y1; 00185 00186 if ( dy > dx ) { 00187 swapxy = 1; 00188 tmp = dx; 00189 dx = dy; 00190 dy = tmp; 00191 tmp = x1; 00192 x1 = y1; 00193 y1 = tmp; 00194 tmp = x2; 00195 x2 = y2; 00196 y2 = tmp; 00197 } 00198 if ( x1 > x2 ) { 00199 tmp = x1; 00200 x1 = x2; 00201 x2 = tmp; 00202 tmp = y1; 00203 y1 = y2; 00204 y2 = tmp; 00205 } 00206 err = dx >> 1; 00207 if ( y2 > y1 ) ystep = 1; 00208 else ystep = -1; 00209 y = y1; 00210 for ( x = x1; x <= x2; x++ ) { 00211 if ( swapxy == 0 ) 00212 setLed(x, y, 1); 00213 else 00214 setLed(y, x, 1); 00215 err -= (uint8_t)dy; 00216 if ( err < 0 ) { 00217 y += (uint8_t)ystep; 00218 err += (uint8_t)dx; 00219 } 00220 } 00221 } 00222 00223 void Matrix::drawCircle_section(int8_t x, int8_t y, int8_t x0, int8_t y0, uint8_t option) 00224 { 00225 /* upper right */ 00226 if ( option & U8G_DRAW_UPPER_RIGHT ) { 00227 setLed(x0 + x, y0 - y, 1); 00228 setLed(x0 + y, y0 - x, 1); 00229 } 00230 00231 /* upper left */ 00232 if ( option & U8G_DRAW_UPPER_LEFT ) { 00233 setLed(x0 - x, y0 - y, 1); 00234 setLed(x0 - y, y0 - x, 1); 00235 } 00236 00237 /* lower right */ 00238 if ( option & U8G_DRAW_LOWER_RIGHT ) { 00239 setLed(x0 + x, y0 + y, 1); 00240 setLed(x0 + y, y0 + x, 1); 00241 } 00242 00243 /* lower left */ 00244 if ( option & U8G_DRAW_LOWER_LEFT ) { 00245 setLed(x0 - x, y0 + y, 1); 00246 setLed(x0 - y, y0 + x, 1); 00247 } 00248 } 00249 00250 void Matrix::drawVLine(int8_t x, int8_t y, int8_t w) 00251 { 00252 if(w<=0) 00253 return; 00254 00255 while (w--) { 00256 setLed(x, y + w, 1); 00257 } 00258 } 00259 00260 void Matrix::drawHLine(int8_t x, int8_t y, int8_t h) 00261 { 00262 if(h<=0) 00263 return; 00264 00265 while (h--) { 00266 setLed(x + h, y, 1); 00267 } 00268 } 00269 00270 void Matrix::drawDisc_section(int8_t x, int8_t y, int8_t x0, int8_t y0, uint8_t option) 00271 { 00272 /* upper right */ 00273 if ( option & U8G_DRAW_UPPER_RIGHT ) { 00274 drawVLine(x0 + x, y0 - y, y + 1); 00275 drawVLine(x0 + y, y0 - x, x + 1); 00276 } 00277 00278 /* upper left */ 00279 if ( option & U8G_DRAW_UPPER_LEFT ) { 00280 drawVLine(x0 - x, y0 - y, y + 1); 00281 drawVLine(x0 - y, y0 - x, x + 1); 00282 } 00283 00284 /* lower right */ 00285 if ( option & U8G_DRAW_LOWER_RIGHT ) { 00286 drawVLine(x0 + x, y0, y + 1); 00287 drawVLine(x0 + y, y0, x + 1); 00288 } 00289 00290 /* lower left */ 00291 if ( option & U8G_DRAW_LOWER_LEFT ) { 00292 drawVLine(x0 - x, y0, y + 1); 00293 drawVLine(x0 - y, y0, x + 1); 00294 } 00295 } 00296 00297 void Matrix::drawCircle(int8_t x0, int8_t y0, int8_t rad, int8_t option) 00298 { 00299 if(rad<=0) 00300 return; 00301 00302 int8_t f; 00303 int8_t ddF_x; 00304 int8_t ddF_y; 00305 uint8_t x; 00306 uint8_t y; 00307 00308 f = 1; 00309 f -= rad; 00310 ddF_x = 1; 00311 ddF_y = 0; 00312 ddF_y -= rad; 00313 ddF_y *= 2; 00314 x = 0; 00315 y = rad; 00316 00317 drawCircle_section(x, y, x0, y0, option); 00318 00319 while ( x < y ) { 00320 if (f >= 0) { 00321 y--; 00322 ddF_y += 2; 00323 f += ddF_y; 00324 } 00325 x++; 00326 ddF_x += 2; 00327 f += ddF_x; 00328 00329 drawCircle_section(x, y, x0, y0, option); 00330 } 00331 } 00332 00333 void Matrix::drawDisc(int8_t x0, int8_t y0, int8_t rad, int8_t option) 00334 { 00335 if(rad<=0) 00336 return; 00337 00338 int8_t f; 00339 int8_t ddF_x; 00340 int8_t ddF_y; 00341 uint8_t x; 00342 uint8_t y; 00343 00344 f = 1; 00345 f -= rad; 00346 ddF_x = 1; 00347 ddF_y = 0; 00348 ddF_y -= rad; 00349 ddF_y *= 2; 00350 x = 0; 00351 y = rad; 00352 00353 drawDisc_section(x, y, x0, y0, option); 00354 00355 while ( x < y ) { 00356 if (f >= 0) { 00357 y--; 00358 ddF_y += 2; 00359 f += ddF_y; 00360 } 00361 x++; 00362 ddF_x += 2; 00363 f += ddF_x; 00364 00365 drawDisc_section(x, y, x0, y0, option); 00366 } 00367 } 00368 00369 void Matrix::drawFrame(int8_t x, int8_t y, int8_t w, int8_t h) 00370 { 00371 if(h<=0 || w<=0) 00372 return; 00373 00374 int8_t xtmp = x; 00375 00376 drawHLine(x, y, w); 00377 drawVLine(x, y, h); 00378 x+=w; 00379 x--; 00380 drawVLine(x, y, h); 00381 y+=h; 00382 y--; 00383 drawHLine(xtmp, y, w); 00384 } 00385 00386 void Matrix::drawRFrame(int8_t x, int8_t y, int8_t w, int8_t h, uint8_t r) 00387 { 00388 if(h<3 || w<3) 00389 return; 00390 00391 if(r>(w-2)/2 || r>(h-2)/2) 00392 r = min((h-2)/2,(w-2)/2); 00393 00394 int8_t xl, yu; 00395 xl = x; 00396 xl += r; 00397 yu = y; 00398 yu += r; 00399 00400 { 00401 int8_t yl, xr; 00402 00403 xr = x; 00404 xr += w; 00405 xr -= r; 00406 xr -= 1; 00407 00408 yl = y; 00409 yl += h; 00410 yl -= r; 00411 yl -= 1; 00412 00413 drawCircle(xl, yu, r, U8G_DRAW_UPPER_LEFT); 00414 drawCircle(xr, yu, r, U8G_DRAW_UPPER_RIGHT); 00415 drawCircle(xl, yl, r, U8G_DRAW_LOWER_LEFT); 00416 drawCircle(xr, yl, r, U8G_DRAW_LOWER_RIGHT); 00417 } 00418 00419 { 00420 int8_t ww, hh; 00421 00422 ww = w; 00423 ww -= r; 00424 ww -= r; 00425 ww -= 2; 00426 hh = h; 00427 hh -= r; 00428 hh -= r; 00429 hh -= 2; 00430 00431 xl++; 00432 yu++; 00433 h--; 00434 w--; 00435 drawHLine(xl, y, ww); 00436 drawHLine(xl, y+h, ww); 00437 drawVLine(x, yu, hh); 00438 drawVLine(x+w, yu, hh); 00439 } 00440 } 00441 00442 void Matrix::drawBox(int8_t x, int8_t y, int8_t w, int8_t h) 00443 { 00444 if(h<=0 || w<=0) 00445 return; 00446 00447 do { 00448 drawHLine(x, y, w); 00449 y++; 00450 h--; 00451 } while( h != 0 ); 00452 } 00453 00454 void Matrix::drawRBox(int8_t x, int8_t y, int8_t w, int8_t h, uint8_t r) 00455 { 00456 if(h<3 || w<3) 00457 return; 00458 00459 if(r>(w-2)/2 || r>(h-2)/2) 00460 r=min((h-2)/2,(w-2)/2); 00461 00462 int8_t xl, yu; 00463 int8_t yl, xr; 00464 00465 00466 xl = x; 00467 xl += r; 00468 yu = y; 00469 yu += r; 00470 00471 xr = x; 00472 xr += w; 00473 xr -= r; 00474 xr -= 1; 00475 00476 yl = y; 00477 yl += h; 00478 yl -= r; 00479 yl -= 1; 00480 00481 drawDisc(xl, yu, r, U8G_DRAW_UPPER_LEFT); 00482 drawDisc(xr, yu, r, U8G_DRAW_UPPER_RIGHT); 00483 drawDisc(xl, yl, r, U8G_DRAW_LOWER_LEFT); 00484 drawDisc(xr, yl, r, U8G_DRAW_LOWER_RIGHT); 00485 00486 { 00487 int8_t ww, hh; 00488 00489 ww = w; 00490 ww -= r; 00491 ww -= r; 00492 ww -= 2; 00493 hh = h; 00494 hh -= r; 00495 hh -= r; 00496 hh -= 2; 00497 00498 xl++; 00499 yu++; 00500 h--; 00501 drawBox(xl, y, ww, r+1); 00502 drawBox(xl, yl, ww, r+1); 00503 // drawHLine(xl, y+h, ww); 00504 drawBox(x, yu, w, hh); 00505 // drawVLine(x+w, yu, hh); 00506 } 00507 } 00508 00509 void Matrix::drawBMP(int16_t x, int16_t y, int16_t w, int16_t h,const uint8_t *bitmap) 00510 { 00511 int16_t i, j, byteWidth = (w + 7) / 8; 00512 00513 for(j=0; j<h; j++) { 00514 for(i=0; i<w; i++ ) { 00515 #if 0 00516 if(pgm_read_byte(bitmap + j * byteWidth + i / 8) & (128 >> ((h-i-1) & 7))) { 00517 setLed(x+i, y+j, 1); 00518 } 00519 #else 00520 if (bitmap[j * byteWidth + i / 8] & (128 >> ((h-i-1) & 7))) { 00521 setLed(x+i, y+j, 1); 00522 } 00523 #endif 00524 } 00525 } 00526 } 00527 00528 #if 0 00529 bool Matrix::drawBMP(int16_t x, int16_t y, const uint8_t *bitmap) 00530 { 00531 uint32_t _dataNum = 0; 00532 uint8_t _dataBuffer[BUFFPIXEL]; //pixel buffer (R+G+B per pixel) 00533 00534 //Parse BMP header 00535 if (read16((uint8_t*)bitmap, _dataNum) == 0x4D42) { //BMP signature 00536 (void)read32((uint8_t*)bitmap, _dataNum); //File size 00537 (void)read32((uint8_t*)bitmap, _dataNum); //Read & ignore creator bytes 00538 uint32_t bmpImageoffset = read32((uint8_t*)bitmap, _dataNum); //Start of image data in file 00539 //Read DIB header 00540 (void)read32((uint8_t*)bitmap, _dataNum); //Header size 00541 int bmpWidth = read32((uint8_t*)bitmap, _dataNum), 00542 bmpHeight = read32((uint8_t*)bitmap, _dataNum); 00543 00544 bool flip = true; //BMP is stored bottom-to-top 00545 //If bmpHeight is negative, image is in top-down order. 00546 if (bmpHeight < 0) { 00547 bmpHeight = -bmpHeight; 00548 flip = false; 00549 } 00550 00551 if (read16((uint8_t*)bitmap, _dataNum) == 1) { //# planes -- must be '1' 00552 uint8_t bmpDepth = read16((uint8_t*)bitmap, _dataNum); //Bit depth (currently must be 24) 00553 if ((bmpDepth == 24) && (read32((uint8_t*)bitmap, _dataNum) == 0)) { //0 = uncompressed 00554 //BMP rows are padded (if needed) to 4-byte boundary 00555 uint32_t rowSize = (bmpWidth * 3 + 3) & ~3; //Not always = bmpWidth; may have padding 00556 00557 //Crop area to be loaded 00558 int w = bmpWidth, 00559 h = bmpHeight; 00560 00561 if ((x + w - 1) >= (getWidth() * 8)) w = (getWidth() * 8) - x; 00562 if ((y + h - 1) >= (getHeight() * 8)) h = (getHeight() * 8) - y; 00563 00564 for (int row = 0; row < h; row++) { //For each scanline... 00565 uint32_t pos = bmpImageoffset + (flip ? (bmpHeight - 1 - row) : row) * rowSize ; 00566 uint8_t buffidx = sizeof(_dataBuffer); //Current position in _dataBuffer 00567 for (int col = 0; col < w; col++) { //For each pixel... 00568 //Time to read more pixel data? 00569 if (buffidx >= sizeof(_dataBuffer)) { //Indeed 00570 buffidx = 0; //Set index to beginning 00571 for (int a = 0; a < BUFFPIXEL; a++) { 00572 _dataBuffer[a] = pgm_read_byte((uint8_t*)bitmap + (pos + a)); 00573 } 00574 } 00575 00576 uint8_t _b = _dataBuffer[buffidx++], 00577 _g = _dataBuffer[buffidx++], 00578 _r = _dataBuffer[buffidx++]; 00579 setLedColor(col + x, row + y, _r, _g, _b); 00580 } //end pixel 00581 } //end scanline 00582 } //end goodBmp 00583 else { 00584 return false; 00585 } 00586 }//end planes 00587 else { 00588 return false; 00589 } 00590 }//end sianatrue 00591 else { 00592 return false; 00593 } 00594 return true; 00595 } 00596 #else 00597 uint8_t _dataBuffer[BUFFPIXEL]; //pixel buffer (R+G+B per pixel) 00598 bool Matrix::drawBMP(int16_t x, int16_t y, const uint8_t *bitmap) 00599 { 00600 uint32_t _dataNum = 0; 00601 uint32_t tempData = 0; 00602 00603 pc.printf("Enter drawBMP()\r\n"); 00604 //Parse BMP header 00605 //if (read16((uint8_t*)bitmap, _dataNum) == 0x4D42) { //BMP signature 00606 if ((bitmap[_dataNum++] == 0x42) && (bitmap[_dataNum++] == 0x4D)) { //BMP signature 00607 pc.printf("Enter if\r\n"); 00608 //(void)read32((uint8_t*)bitmap, _dataNum); //File size 00609 _dataNum += 4; //File size 00610 //(void)read32((uint8_t*)bitmap, _dataNum); //Read & ignore creator bytes 00611 _dataNum += 4; //Read & ignore creator bytes 00612 //uint32_t bmpImageoffset = read32((uint8_t*)bitmap, _dataNum); //Start of image data in file 00613 uint32_t bmpImageoffset = bitmap[_dataNum] | bitmap[_dataNum+1]<<8 | bitmap[_dataNum+2]<< 16 | bitmap[_dataNum+3] << 24; //Start of image data in file 00614 _dataNum += 4; 00615 pc.printf("bmpImageoffset = %u\r\n", bmpImageoffset); 00616 //Read DIB header 00617 //(void)read32((uint8_t*)bitmap, _dataNum); //Header size 00618 _dataNum += 4; //Header size 00619 //int bmpWidth = read32((uint8_t*)bitmap, _dataNum); 00620 int bmpWidth = bitmap[_dataNum] | bitmap[_dataNum+1]<<8 | bitmap[_dataNum+2]<< 16 | bitmap[_dataNum+3] << 24; 00621 _dataNum += 4; 00622 //int bmpHeight = read32((uint8_t*)bitmap, _dataNum); 00623 int bmpHeight = bitmap[_dataNum] | bitmap[_dataNum+1]<<8 | bitmap[_dataNum+2]<< 16 | bitmap[_dataNum+3] << 24; 00624 _dataNum += 4; 00625 00626 bool flip = true; //BMP is stored bottom-to-top 00627 //If bmpHeight is negative, image is in top-down order. 00628 if (bmpHeight < 0) { 00629 bmpHeight = -bmpHeight; 00630 flip = false; 00631 } 00632 00633 //if (read16((uint8_t*)bitmap, _dataNum) == 1) { //# planes -- must be '1' 00634 if ((bitmap[_dataNum] | bitmap[_dataNum+1]<<8) == 1) { //# planes -- must be '1' 00635 _dataNum += 2; 00636 //uint8_t bmpDepth = read16((uint8_t*)bitmap, _dataNum); //Bit depth (currently must be 24) 00637 uint8_t bmpDepth = bitmap[_dataNum] | bitmap[_dataNum+1]<<8; //Bit depth (currently must be 24) 00638 _dataNum += 2; 00639 tempData = bitmap[_dataNum] | bitmap[_dataNum+1]<<8 | bitmap[_dataNum+2]<< 16 | bitmap[_dataNum+3] << 24; 00640 _dataNum += 4; 00641 //if ((bmpDepth == 24) && (read32((uint8_t*)bitmap, _dataNum) == 0)) { //0 = uncompressed 00642 if ((bmpDepth == 24) && (tempData == 0)) { //0 = uncompressed 00643 //BMP rows are padded (if needed) to 4-byte boundary 00644 uint32_t rowSize = (bmpWidth * 3 + 3) & ~3; //Not always = bmpWidth; may have padding 00645 00646 //Crop area to be loaded 00647 int w = bmpWidth, 00648 h = bmpHeight; 00649 00650 if ((x + w - 1) >= (getWidth() * 8)) w = (getWidth() * 8) - x; 00651 if ((y + h - 1) >= (getHeight() * 8)) h = (getHeight() * 8) - y; 00652 00653 for (int row = 0; row < h; row++) { //For each scanline... 00654 uint32_t pos = bmpImageoffset + (flip ? (bmpHeight - 1 - row) : row) * rowSize ; 00655 uint8_t buffidx = sizeof(_dataBuffer); //Current position in _dataBuffer 00656 for (int col = 0; col < w; col++) { //For each pixel... 00657 //Time to read more pixel data? 00658 if (buffidx >= sizeof(_dataBuffer)) { //Indeed 00659 buffidx = 0; //Set index to beginning 00660 for (int a = 0; a < BUFFPIXEL; a++) { 00661 _dataBuffer[a] = pgm_read_byte((uint8_t*)bitmap + (pos + a)); 00662 } 00663 } 00664 00665 uint8_t _b = _dataBuffer[buffidx++], 00666 _g = _dataBuffer[buffidx++], 00667 _r = _dataBuffer[buffidx++]; 00668 setLedColor(col + x, row + y, _r, _g, _b); 00669 } //end pixel 00670 } //end scanline 00671 } //end goodBmp 00672 else { 00673 return false; 00674 } 00675 }//end planes 00676 else { 00677 return false; 00678 } 00679 }//end sianatrue 00680 else { 00681 return false; 00682 } 00683 return true; 00684 } 00685 #endif 00686 00687 void Matrix::writeString(char* _c, bool _m, uint16_t _t, int16_t _xy) 00688 { 00689 setFontMode(_m); 00690 int c1 = (_m ? getWidth() : getHeight()) * 8; 00691 int c2 = -(_m ? getStringWidth(_c) : getStringHeight(_c)) - c1; 00692 for (int a = c1; a > c2; a--) { 00693 setCursor((_m ? a : _xy), (_m ? _xy : a)); 00694 print(_c); 00695 wait_ms(_t); 00696 #ifdef WDT 00697 //wdt_reset(); 00698 #endif 00699 } 00700 } 00701 00702 size_t Matrix::write(uint8_t c) 00703 { 00704 if (CharToInt(c) > 94 || CharToInt(c) < 0) 00705 return 0; 00706 00707 for (int a = 0; a < getMatrixNum(); a++) 00708 led[a].write(c); 00709 00710 return 1; 00711 /* void Matrix::print(char* _c) { 00712 for (int a = 0; a < this->_matrixNum; a++) 00713 led[a].print(_c); 00714 } */ 00715 } 00716 00717 int16_t Matrix::getStringWidth(char * _String) 00718 { 00719 // return (uint32_t)(offset + millis() / 1000); 00720 int _leng = 0; 00721 int _Width = 0; 00722 while (_String[_leng] != NULL) { 00723 #if 0 00724 _Width += 1 + pgm_read_byte(alphabetBitmap[(_String[_leng] - 32)] + FONE_SIZE_X); 00725 #else 00726 //_Width += (1 + alphabetBitmap[((int)_String[_leng] - 32)] + FONE_SIZE_X); 00727 _Width += 1 + FONE_SIZE_X; 00728 #endif 00729 _leng++; 00730 } 00731 return _Width; 00732 } 00733 00734 int16_t Matrix::getStringHeight(char* _String) 00735 { 00736 // return (uint32_t)(offset + millis() / 1000); 00737 int _leng = 0; 00738 int _Height = 0; 00739 while (_String[_leng] != NULL) { 00740 _Height += 1 + FONE_SIZE_Y; 00741 _leng++; 00742 } 00743 return _Height; 00744 } 00745 00746 int16_t Matrix::getMatrixNum() 00747 { 00748 return this->_matrixNum; 00749 } 00750 00751 int16_t Matrix::getWidth() 00752 { 00753 return this->_numX; 00754 } 00755 00756 int16_t Matrix::getHeight() 00757 { 00758 return this->_numY; 00759 }
Generated on Thu Jul 14 2022 22:36:21 by
1.7.2