Hugging Face's logo

Datasets:
Beifengdo
/
Arduino-Development

Languages:
Chinese
Tags:
education
arduino
embedded
cplusplus
archive
Dataset card Files
xet
 Community
Arduino-Development / libraries /Robot_Control /src /lcd.cpp
Beifengdo's picture
Beifengdo
Archive original Arduino development files (part 8)
a9536d3 verified
Raw History Blame
8.95 kB
/*
Copyright (c) 2012 Arduino LLC. All right reserved.
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*/
#include "ArduinoRobot.h"
#include "Wire.h"
#define BUFFPIXEL 20
bool cmp(char* str1, char* str2, uint8_t len);
uint16_t read16(Fat16& f);
uint32_t read32(Fat16& f);
//uint16_t color565(uint8_t r, uint8_t g, uint8_t b);
void RobotControl::beginTFT(uint16_t foreGround, uint16_t backGround){
//TFT initialization
Arduino_LCD::initB();
Arduino_LCD::fillScreen(backGround);
Arduino_LCD::setTextColor(foreGround);
Arduino_LCD::setTextSize(1);
this->foreGround=foreGround;
this->backGround=backGround;
}
void RobotControl::_enableLCD(){
DDRB = DDRB & 0xEF; //pinMode(CS_SD,INPUT);
DDRB = DDRB | 0x20; //pinMode(CS_LCD,OUTPUT);
}
/*void RobotControl::_setErase(uint8_t posX, uint8_t posY){
Arduino_LCD::setCursor(posX,posY);
Arduino_LCD::setTextColor(backGround);
Arduino_LCD::setTextSize(1);
}
void RobotControl::_setWrite(uint8_t posX, uint8_t posY){
Arduino_LCD::setCursor(posX,posY);
Arduino_LCD::setTextColor(foreGround);
Arduino_LCD::setTextSize(1);
}*/
/*
void RobotControl::text(int value, uint8_t posX, uint8_t posY, bool EW){
if(EW)
_setWrite(posX,posY);
else
_setErase(posX,posY);
Arduino_LCD::print(value);
}
void RobotControl::text(long value, uint8_t posX, uint8_t posY, bool EW){
if(EW)
_setWrite(posX,posY);
else
_setErase(posX,posY);
Arduino_LCD::print(value);
}
void RobotControl::text(char* value, uint8_t posX, uint8_t posY, bool EW){
if(EW)
_setWrite(posX,posY);
else
_setErase(posX,posY);
Arduino_LCD::print(value);
}
void RobotControl::text(char value, uint8_t posX, uint8_t posY, bool EW){
if(EW)
_setWrite(posX,posY);
else
_setErase(posX,posY);
Arduino_LCD::print(value);
}
*/
void RobotControl::debugPrint(long value, uint8_t x, uint8_t y){
static long oldVal=0;
Arduino_LCD::stroke(backGround);
text(oldVal,x,y);
Arduino_LCD::stroke(foreGround);
text(value,x,y);
oldVal=value;
}
void RobotControl::clearScreen(){
Arduino_LCD::fillScreen(backGround);
}
void RobotControl::drawBMP(char* filename, uint8_t x, uint8_t y){
/*for(int j=0;j<NUM_EEPROM_BMP;j++){
Serial.println(_eeprom_bmp[j].name);
Serial.print(" ");
Serial.print(_eeprom_bmp[j].address);
Serial.print(" ");
Serial.print(_eeprom_bmp[j].width);
Serial.print(" ");
Serial.println(_eeprom_bmp[j].height);
}
Serial.println();*/
if(_isEEPROM_BMP_Allocated){
for(int i=0;i<NUM_EEPROM_BMP;i++){
if(cmp(_eeprom_bmp[i].name,filename,7)){
/*Serial.println(_eeprom_bmp[i].name);
Serial.print(" ");
Serial.print(_eeprom_bmp[i].address);
Serial.print(" ");
Serial.print(_eeprom_bmp[i].width);
Serial.print(" ");
Serial.println(_eeprom_bmp[i].height);*/
_drawBMP(_eeprom_bmp[i].address,x,y,_eeprom_bmp[i].width,_eeprom_bmp[i].height);
return;
}
}
}else{
_drawBMP(filename,x,y);//goes to SD
}
}
bool cmp(char* str1, char* str2, uint8_t len){
for(uint8_t i=0;i<len;i++){
if(str1[i]==' ')break;
if(str1[i]!=str2[i])return false;
}
return true;
}
void RobotControl::_drawBMP(uint32_t iconOffset, uint8_t x, uint8_t y, uint8_t width, uint8_t height){
uint8_t screenWidth=Arduino_LCD::width();
uint8_t screenHeight=Arduino_LCD::height();
if((x >= screenWidth) || (y >= screenHeight)) return;
// Crop area to be loaded
if((x+width-1) >= screenWidth) width = screenWidth - x;
if((y+height-1) >= screenHeight) height = screenHeight - y;
// Set TFT address window to clipped image bounds
Arduino_LCD::setAddrWindow(x, y, x+width-1, y+height-1);
// launch the reading command
_drawBMP_EEPROM(iconOffset, width, height);
}
// Draw BMP from SD card through the filename
void RobotControl::_drawBMP(char* filename, uint8_t posX, uint8_t posY){
uint8_t bmpWidth, bmpHeight; // W+H in pixels
uint8_t bmpDepth; // Bit depth (currently must be 24)
uint32_t bmpImageoffset; // Start of image data in file
uint32_t rowSize; // Not always = bmpWidth; may have padding
uint8_t sdbuffer[3*BUFFPIXEL]; // pixel buffer (R+G+B per pixel)
uint8_t buffidx = sizeof(sdbuffer); // Current position in sdbuffer
bool goodBmp = false; // Set to true on valid header parse
bool flip = true; // BMP is stored bottom-to-top
uint8_t w, h, row, col;
uint8_t r, g, b;
uint32_t pos = 0;
// Open requested file on SD card
if ((file.open(filename,O_READ)) == NULL) {
return;
}
// Parse BMP header
if(read16(file) == 0x4D42) { // BMP signature
read32(file);//uint32_t aux = read32(file);
(void)read32(file); // Read & ignore creator bytes
bmpImageoffset = read32(file); // Start of image data
// Read DIB header
(void)read32(file);//aux = read32(file);
bmpWidth = read32(file);
bmpHeight = read32(file);
if(read16(file) == 1) { // # planes -- must be '1'
bmpDepth = read16(file); // bits per pixel
if((bmpDepth == 24) && (read32(file) == 0)) { // 0 = uncompressed
goodBmp = true; // Supported BMP format -- proceed!
// BMP rows are padded (if needed) to 4-byte boundary
rowSize = (bmpWidth * 3 + 3) & ~3;
// If bmpHeight is negative, image is in top-down order.
// This is not canon but has been observed in the wild.
if(bmpHeight < 0) {
bmpHeight = -bmpHeight;
flip = false;
}
// Crop area to be loaded
w = bmpWidth;
h = bmpHeight;
// Start drawing
//_enableLCD();
Arduino_LCD::setAddrWindow(posX, posY, posX+bmpWidth-1, posY+bmpHeight-1);
for (row=0; row<h; row++) { // For each scanline...
if(flip) // Bitmap is stored bottom-to-top order (normal BMP)
pos = bmpImageoffset + (bmpHeight - 1 - row) * rowSize;
else // Bitmap is stored top-to-bottom
pos = bmpImageoffset + row * rowSize;
if(file.curPosition() != pos) { // Need seek?
//_enableSD();
file.seekSet(pos);
buffidx = sizeof(sdbuffer); // Force buffer reload
//_enableLCD();
}
for (col=0; col<w; col++) { // For each pixel...
// Time to read more pixel data?
if (buffidx >= sizeof(sdbuffer)) { // Indeed
//_enableSD();
file.read(sdbuffer, sizeof(sdbuffer));
buffidx = 0; // Set index to beginning
//_enableLCD();
}
// Convert pixel from BMP to TFT format, push to display
b = sdbuffer[buffidx++];
g = sdbuffer[buffidx++];
r = sdbuffer[buffidx++];
int color = Arduino_LCD::Color565(r,g,b);
Arduino_LCD::pushColor(color);
} // end pixel
} // end scanline
//_enableSD();
} // end goodBmp*/
}
}
file.close();
//_enableLCD();
}
uint16_t read16(Fat16& f) {
uint16_t result;
f.read(&result,sizeof(result));
return result;
}
uint32_t read32(Fat16& f) {
uint32_t result;
f.read(&result,sizeof(result));
return result;
}
/*
uint16_t color565(uint8_t r, uint8_t g, uint8_t b) {
return ((r & 0xF8) << 8) | ((g & 0xFC) << 3) | (b >> 3);
}*/
void RobotControl::_drawBMP_EEPROM(uint16_t address, uint8_t width, uint8_t height){
uint16_t u16retVal = 0;
EEPROM_I2C::_beginTransmission(address);
EEPROM_I2C::_endTransmission();
/*Wire.beginTransmission(DEVICEADDRESS);
Wire.write( (address >> 8) & 0xFF );
Wire.write( (address >> 0) & 0xFF );
Wire.endTransmission();*/
long s = width * height ;
for(long j = 0; j < (long) s >> 4; j++) { // divided by 32, times 2
Wire.requestFrom(DEVICEADDRESS, 32);
for(int i = 0; i < 32; i+=2) {
u16retVal = Wire.read();
u16retVal = (u16retVal << 8) + Wire.read();
Arduino_LCD::pushColor(u16retVal);
}
}
}
void RobotControl::beginBMPFromEEPROM(){
_eeprom_bmp=(EEPROM_BMP*)malloc(NUM_EEPROM_BMP*sizeof(EEPROM_BMP));
EEPROM_I2C::_beginTransmission(0);
EEPROM_I2C::_endTransmission();
for(uint8_t j=0;j<NUM_EEPROM_BMP;j++){
Wire.requestFrom(DEVICEADDRESS, sizeof(EEPROM_BMP));
for(uint8_t i=0;i<8;i++){
_eeprom_bmp[j].name[i]=Wire.read();//name
}
_eeprom_bmp[j].width=Wire.read();//width
_eeprom_bmp[j].height=Wire.read();//height
_eeprom_bmp[j].address=Wire.read();
_eeprom_bmp[j].address=_eeprom_bmp[j].address + (Wire.read() << 8);//address
}
_isEEPROM_BMP_Allocated=true;
}
void RobotControl::endBMPFromEEPROM(){
free(_eeprom_bmp);
_isEEPROM_BMP_Allocated=false;
}