unixweb/funkwetter-display
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Added Software

Browse Source
This commit is contained in:
Joachim Hummel
2022-06-19 11:10:04 +00:00
parent c729e2062b
commit e76db08b77
199 changed files with 69643 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

113
Software/libraries/Adafruit_GFX-Library/examples/GFXcanvas/GFXcanvas.ino Normal file
View File

@ -0,0 +1,113 @@
/***
This example is intended to demonstrate the use of getPixel() versus
getRawPixel() and the fast horizontal and vertical drawing routines
in the GFXcanvas family of classes,
When using the GFXcanvas* classes as the image buffer for a hardware driver,
there is a need to get individual pixel color values at given physical
coordinates. Rather than subclasses or client classes call getBuffer() and
reinterpret the byte layout of the buffer, two methods are added to each of the
GFXcanvas* classes that allow fetching of specific pixel values.
* getPixel(x, y) : Gets the pixel color value at the rotated coordinates in
the image.
* getRawPixel(x,y) : Gets the pixel color value at the unrotated coordinates
in the image. This is useful for getting the pixel value to map to a hardware
pixel location. This method was made protected as only the hardware driver
should be accessing it.
The GFXcanvas*SerialDemo classes in this example will print to Serial the
contents of the underlying GFXcanvas buffer in both the current rotated layout
and the underlying physical layout.
***/
#include "GFXcanvasSerialDemo.h"
#include <Arduino.h>
void setup() {
Serial.begin(115200);
// first create a rectangular GFXcanvas8SerialDemo object and draw to it
GFXcanvas8SerialDemo demo8(21, 11);
demo8.fillScreen(0x00);
demo8.setRotation(1); // now canvas is 11x21
demo8.fillCircle(5, 10, 5, 0xAA);
demo8.writeFastHLine(0, 0, 11, 0x11);
demo8.writeFastHLine(10, 10, -11, 0x22);
demo8.writeFastHLine(0, 20, 11, 0x33);
demo8.writeFastVLine(0, 0, 21, 0x44);
demo8.writeFastVLine(10, 20, -21, 0x55);
Serial.println("Demonstrating GFXcanvas rotated and raw pixels.\n");
// print it out rotated
Serial.println("The canvas's content in the rotation of '0':\n");
demo8.setRotation(0);
demo8.print(true);
Serial.println("\n");
Serial.println("The canvas's content in the rotation of '1' (which is what "
"it was drawn in):\n");
demo8.setRotation(1);
demo8.print(true);
Serial.println("\n");
Serial.println("The canvas's content in the rotation of '2':\n");
demo8.setRotation(2);
demo8.print(true);
Serial.println("\n");
Serial.println("The canvas's content in the rotation of '3':\n");
demo8.setRotation(3);
demo8.print(true);
Serial.println("\n");
// print it out unrotated
Serial.println("The canvas's content in it's raw, physical layout:\n");
demo8.print(false);
Serial.println("\n");
// Demonstrate GFXcanvas1SerialDemo
GFXcanvas1SerialDemo demo1(21, 11);
demo1.fillScreen(0);
demo1.setRotation(0);
demo1.writeFastHLine(0, 0, 9, 1);
demo1.setRotation(1);
demo1.writeFastHLine(0, 0, 9, 1);
demo1.setRotation(2);
demo1.writeFastHLine(0, 0, 9, 1);
demo1.setRotation(3);
demo1.writeFastHLine(0, 0, 9, 1);
demo1.setRotation(1);
demo1.fillRect(3, 8, 5, 5, 1);
Serial.println("\nThe GFXcanvas1 raw content after drawing a fast horizontal "
"line in each rotation:\n");
demo1.print(false);
Serial.println("\n");
// Demonstrate GFXcanvas16SerialDemo
GFXcanvas16SerialDemo demo16(21, 11);
demo16.fillScreen(0);
demo16.setRotation(0);
demo16.writeFastHLine(0, 0, 9, 0x1111);
demo16.setRotation(1);
demo16.writeFastHLine(0, 0, 9, 0x2222);
demo16.setRotation(2);
demo16.writeFastHLine(0, 0, 9, 0x3333);
demo16.setRotation(3);
demo16.writeFastHLine(0, 0, 9, 0x4444);
demo16.setRotation(1);
demo16.fillRect(3, 8, 5, 5, 0x8888);
Serial.println("\nThe GFXcanvas16 raw content after drawing a fast "
"horizontal line in each rotation:\n");
demo16.print(false);
Serial.println("\n");
}
void loop() {}

92
Software/libraries/Adafruit_GFX-Library/examples/GFXcanvas/GFXcanvasSerialDemo.cpp Normal file
View File

@ -0,0 +1,92 @@
#include "GFXcanvasSerialDemo.h"
#include <Arduino.h>
GFXcanvas1SerialDemo::GFXcanvas1SerialDemo(uint16_t w, uint16_t h)
: GFXcanvas1(w, h) {}
void GFXcanvas1SerialDemo::print(bool rotated) {
char pixel_buffer[8];
uint16_t width, height;
if (rotated) {
width = this->width();
height = this->height();
} else {
width = this->WIDTH;
height = this->HEIGHT;
}
for (uint16_t y = 0; y < height; y++) {
for (uint16_t x = 0; x < width; x++) {
bool pixel;
if (rotated) {
pixel = this->getPixel(x, y);
} else {
pixel = this->getRawPixel(x, y);
}
sprintf(pixel_buffer, " %d", pixel);
Serial.print(pixel_buffer);
}
Serial.print("\n");
}
}
GFXcanvas8SerialDemo::GFXcanvas8SerialDemo(uint16_t w, uint16_t h)
: GFXcanvas8(w, h) {}
void GFXcanvas8SerialDemo::print(bool rotated) {
char pixel_buffer[8];
uint16_t width, height;
if (rotated) {
width = this->width();
height = this->height();
} else {
width = this->WIDTH;
height = this->HEIGHT;
}
for (uint16_t y = 0; y < height; y++) {
for (uint16_t x = 0; x < width; x++) {
uint8_t pixel;
if (rotated) {
pixel = this->getPixel(x, y);
} else {
pixel = this->getRawPixel(x, y);
}
sprintf(pixel_buffer, " %02x", pixel);
Serial.print(pixel_buffer);
}
Serial.print("\n");
}
}
GFXcanvas16SerialDemo::GFXcanvas16SerialDemo(uint16_t w, uint16_t h)
: GFXcanvas16(w, h) {}
void GFXcanvas16SerialDemo::print(bool rotated) {
char pixel_buffer[8];
uint16_t width, height;
if (rotated) {
width = this->width();
height = this->height();
} else {
width = this->WIDTH;
height = this->HEIGHT;
}
for (uint16_t y = 0; y < height; y++) {
for (uint16_t x = 0; x < width; x++) {
uint16_t pixel;
if (rotated) {
pixel = this->getPixel(x, y);
} else {
pixel = this->getRawPixel(x, y);
}
sprintf(pixel_buffer, " %04x", pixel);
Serial.print(pixel_buffer);
}
Serial.print("\n");
}
}

65
Software/libraries/Adafruit_GFX-Library/examples/GFXcanvas/GFXcanvasSerialDemo.h Normal file
View File

@ -0,0 +1,65 @@
#ifndef __GFXcanvasSerialDemo__
#define __GFXcanvasSerialDemo__
#include <Adafruit_GFX.h>
/**********************************************************************/
/*!
@brief Demonstrates using the GFXconvas classes as the backing store
for a device driver.
*/
/**********************************************************************/
class GFXcanvas1SerialDemo : public GFXcanvas1 {
public:
GFXcanvas1SerialDemo(uint16_t w, uint16_t h);
/**********************************************************************/
/*!
@brief Prints the current contents of the canvas to Serial
@param rotated true to print according to the current GFX rotation,
false to print to the native rotation of the canvas (or unrotated).
*/
/**********************************************************************/
void print(bool rotated);
};
/**********************************************************************/
/*!
@brief Demonstrates using the GFXconvas classes as the backing store
for a device driver.
*/
/**********************************************************************/
class GFXcanvas8SerialDemo : public GFXcanvas8 {
public:
GFXcanvas8SerialDemo(uint16_t w, uint16_t h);
/**********************************************************************/
/*!
@brief Prints the current contents of the canvas to Serial
@param rotated true to print according to the current GFX rotation,
false to print to the native rotation of the canvas (or unrotated).
*/
/**********************************************************************/
void print(bool rotated);
};
/**********************************************************************/
/*!
@brief Demonstrates using the GFXconvas classes as the backing store
for a device driver.
*/
/**********************************************************************/
class GFXcanvas16SerialDemo : public GFXcanvas16 {
public:
GFXcanvas16SerialDemo(uint16_t w, uint16_t h);
/**********************************************************************/
/*!
@brief Prints the current contents of the canvas to Serial
@param rotated true to print according to the current GFX rotation,
false to print to the native rotation of the canvas (or unrotated).
*/
/**********************************************************************/
void print(bool rotated);
};
#endif // __GFXcanvasSerialDemo__

365
Software/libraries/Adafruit_GFX-Library/examples/mock_ili9341/mock_ili9341.ino Normal file
View File

@ -0,0 +1,365 @@
/***************************************************
This is our GFX example for the Adafruit ILI9341 Breakout and Shield
----> http://www.adafruit.com/products/1651
Check out the links above for our tutorials and wiring diagrams
These displays use SPI to communicate, 4 or 5 pins are required to
interface (RST is optional)
Adafruit invests time and resources providing this open source code,
please support Adafruit and open-source hardware by purchasing
products from Adafruit!
Written by Limor Fried/Ladyada for Adafruit Industries.
MIT license, all text above must be included in any redistribution
****************************************************/
#include "SPI.h"
#include "Adafruit_GFX.h"
#include "Adafruit_ILI9341.h"
// For the Adafruit shield, these are the default.
#define TFT_DC 9
#define TFT_CS 10
// Use hardware SPI (on Uno, #13, #12, #11) and the above for CS/DC
Adafruit_ILI9341 tft = Adafruit_ILI9341(TFT_CS, TFT_DC);
// If using the breakout, change pins as desired
//Adafruit_ILI9341 tft = Adafruit_ILI9341(TFT_CS, TFT_DC, TFT_MOSI, TFT_CLK, TFT_RST, TFT_MISO);
void setup() {
Serial.begin(9600);
Serial.println("ILI9341 Test!");
tft.begin();
// read diagnostics (optional but can help debug problems)
uint8_t x = tft.readcommand8(ILI9341_RDMODE);
Serial.print("Display Power Mode: 0x"); Serial.println(x, HEX);
x = tft.readcommand8(ILI9341_RDMADCTL);
Serial.print("MADCTL Mode: 0x"); Serial.println(x, HEX);
x = tft.readcommand8(ILI9341_RDPIXFMT);
Serial.print("Pixel Format: 0x"); Serial.println(x, HEX);
x = tft.readcommand8(ILI9341_RDIMGFMT);
Serial.print("Image Format: 0x"); Serial.println(x, HEX);
x = tft.readcommand8(ILI9341_RDSELFDIAG);
Serial.print("Self Diagnostic: 0x"); Serial.println(x, HEX);
Serial.println(F("Benchmark Time (microseconds)"));
delay(10);
Serial.print(F("Screen fill "));
Serial.println(testFillScreen());
delay(500);
Serial.print(F("Text "));
Serial.println(testText());
delay(3000);
Serial.print(F("Lines "));
Serial.println(testLines(ILI9341_CYAN));
delay(500);
Serial.print(F("Horiz/Vert Lines "));
Serial.println(testFastLines(ILI9341_RED, ILI9341_BLUE));
delay(500);
Serial.print(F("Rectangles (outline) "));
Serial.println(testRects(ILI9341_GREEN));
delay(500);
Serial.print(F("Rectangles (filled) "));
Serial.println(testFilledRects(ILI9341_YELLOW, ILI9341_MAGENTA));
delay(500);
Serial.print(F("Circles (filled) "));
Serial.println(testFilledCircles(10, ILI9341_MAGENTA));
Serial.print(F("Circles (outline) "));
Serial.println(testCircles(10, ILI9341_WHITE));
delay(500);
Serial.print(F("Triangles (outline) "));
Serial.println(testTriangles());
delay(500);
Serial.print(F("Triangles (filled) "));
Serial.println(testFilledTriangles());
delay(500);
Serial.print(F("Rounded rects (outline) "));
Serial.println(testRoundRects());
delay(500);
Serial.print(F("Rounded rects (filled) "));
Serial.println(testFilledRoundRects());
delay(500);
Serial.println(F("Done!"));
}
void loop(void) {
for(uint8_t rotation=0; rotation<4; rotation++) {
tft.setRotation(rotation);
testText();
delay(1000);
}
}
unsigned long testFillScreen() {
unsigned long start = micros();
tft.fillScreen(ILI9341_BLACK);
yield();
tft.fillScreen(ILI9341_RED);
yield();
tft.fillScreen(ILI9341_GREEN);
yield();
tft.fillScreen(ILI9341_BLUE);
yield();
tft.fillScreen(ILI9341_BLACK);
yield();
return micros() - start;
}
unsigned long testText() {
tft.fillScreen(ILI9341_BLACK);
unsigned long start = micros();
tft.setCursor(0, 0);
tft.setTextColor(ILI9341_WHITE); tft.setTextSize(1);
tft.println("Hello World!");
tft.setTextColor(ILI9341_YELLOW); tft.setTextSize(2);
tft.println(1234.56);
tft.setTextColor(ILI9341_RED); tft.setTextSize(3);
tft.println(0xDEADBEEF, HEX);
tft.println();
tft.setTextColor(ILI9341_GREEN);
tft.setTextSize(5);
tft.println("Groop");
tft.setTextSize(2);
tft.println("I implore thee,");
tft.setTextSize(1);
tft.println("my foonting turlingdromes.");
tft.println("And hooptiously drangle me");
tft.println("with crinkly bindlewurdles,");
tft.println("Or I will rend thee");
tft.println("in the gobberwarts");
tft.println("with my blurglecruncheon,");
tft.println("see if I don't!");
return micros() - start;
}
unsigned long testLines(uint16_t color) {
unsigned long start, t;
int x1, y1, x2, y2,
w = tft.width(),
h = tft.height();
tft.fillScreen(ILI9341_BLACK);
yield();
x1 = y1 = 0;
y2 = h - 1;
start = micros();
for(x2=0; x2<w; x2+=6) tft.drawLine(x1, y1, x2, y2, color);
x2 = w - 1;
for(y2=0; y2<h; y2+=6) tft.drawLine(x1, y1, x2, y2, color);
t = micros() - start; // fillScreen doesn't count against timing
yield();
tft.fillScreen(ILI9341_BLACK);
yield();
x1 = w - 1;
y1 = 0;
y2 = h - 1;
start = micros();
for(x2=0; x2<w; x2+=6) tft.drawLine(x1, y1, x2, y2, color);
x2 = 0;
for(y2=0; y2<h; y2+=6) tft.drawLine(x1, y1, x2, y2, color);
t += micros() - start;
yield();
tft.fillScreen(ILI9341_BLACK);
yield();
x1 = 0;
y1 = h - 1;
y2 = 0;
start = micros();
for(x2=0; x2<w; x2+=6) tft.drawLine(x1, y1, x2, y2, color);
x2 = w - 1;
for(y2=0; y2<h; y2+=6) tft.drawLine(x1, y1, x2, y2, color);
t += micros() - start;
yield();
tft.fillScreen(ILI9341_BLACK);
yield();
x1 = w - 1;
y1 = h - 1;
y2 = 0;
start = micros();
for(x2=0; x2<w; x2+=6) tft.drawLine(x1, y1, x2, y2, color);
x2 = 0;
for(y2=0; y2<h; y2+=6) tft.drawLine(x1, y1, x2, y2, color);
yield();
return micros() - start;
}
unsigned long testFastLines(uint16_t color1, uint16_t color2) {
unsigned long start;
int x, y, w = tft.width(), h = tft.height();
tft.fillScreen(ILI9341_BLACK);
start = micros();
for(y=0; y<h; y+=5) tft.drawFastHLine(0, y, w, color1);
for(x=0; x<w; x+=5) tft.drawFastVLine(x, 0, h, color2);
return micros() - start;
}
unsigned long testRects(uint16_t color) {
unsigned long start;
int n, i, i2,
cx = tft.width() / 2,
cy = tft.height() / 2;
tft.fillScreen(ILI9341_BLACK);
n = min(tft.width(), tft.height());
start = micros();
for(i=2; i<n; i+=6) {
i2 = i / 2;
tft.drawRect(cx-i2, cy-i2, i, i, color);
}
return micros() - start;
}
unsigned long testFilledRects(uint16_t color1, uint16_t color2) {
unsigned long start, t = 0;
int n, i, i2,
cx = tft.width() / 2 - 1,
cy = tft.height() / 2 - 1;
tft.fillScreen(ILI9341_BLACK);
n = min(tft.width(), tft.height());
for(i=n; i>0; i-=6) {
i2 = i / 2;
start = micros();
tft.fillRect(cx-i2, cy-i2, i, i, color1);
t += micros() - start;
// Outlines are not included in timing results
tft.drawRect(cx-i2, cy-i2, i, i, color2);
yield();
}
return t;
}
unsigned long testFilledCircles(uint8_t radius, uint16_t color) {
unsigned long start;
int x, y, w = tft.width(), h = tft.height(), r2 = radius * 2;
tft.fillScreen(ILI9341_BLACK);
start = micros();
for(x=radius; x<w; x+=r2) {
for(y=radius; y<h; y+=r2) {
tft.fillCircle(x, y, radius, color);
}
}
return micros() - start;
}
unsigned long testCircles(uint8_t radius, uint16_t color) {
unsigned long start;
int x, y, r2 = radius * 2,
w = tft.width() + radius,
h = tft.height() + radius;
// Screen is not cleared for this one -- this is
// intentional and does not affect the reported time.
start = micros();
for(x=0; x<w; x+=r2) {
for(y=0; y<h; y+=r2) {
tft.drawCircle(x, y, radius, color);
}
}
return micros() - start;
}
unsigned long testTriangles() {
unsigned long start;
int n, i, cx = tft.width() / 2 - 1,
cy = tft.height() / 2 - 1;
tft.fillScreen(ILI9341_BLACK);
n = min(cx, cy);
start = micros();
for(i=0; i<n; i+=5) {
tft.drawTriangle(
cx , cy - i, // peak
cx - i, cy + i, // bottom left
cx + i, cy + i, // bottom right
tft.color565(i, i, i));
}
return micros() - start;
}
unsigned long testFilledTriangles() {
unsigned long start, t = 0;
int i, cx = tft.width() / 2 - 1,
cy = tft.height() / 2 - 1;
tft.fillScreen(ILI9341_BLACK);
start = micros();
for(i=min(cx,cy); i>10; i-=5) {
start = micros();
tft.fillTriangle(cx, cy - i, cx - i, cy + i, cx + i, cy + i,
tft.color565(0, i*10, i*10));
t += micros() - start;
tft.drawTriangle(cx, cy - i, cx - i, cy + i, cx + i, cy + i,
tft.color565(i*10, i*10, 0));
yield();
}
return t;
}
unsigned long testRoundRects() {
unsigned long start;
int w, i, i2,
cx = tft.width() / 2 - 1,
cy = tft.height() / 2 - 1;
tft.fillScreen(ILI9341_BLACK);
w = min(tft.width(), tft.height());
start = micros();
for(i=0; i<w; i+=6) {
i2 = i / 2;
tft.drawRoundRect(cx-i2, cy-i2, i, i, i/8, tft.color565(i, 0, 0));
}
return micros() - start;
}
unsigned long testFilledRoundRects() {
unsigned long start;
int i, i2,
cx = tft.width() / 2 - 1,
cy = tft.height() / 2 - 1;
tft.fillScreen(ILI9341_BLACK);
start = micros();
for(i=min(tft.width(), tft.height()); i>20; i-=6) {
i2 = i / 2;
tft.fillRoundRect(cx-i2, cy-i2, i, i, i/8, tft.color565(0, i, 0));
yield();
}
return micros() - start;
}