bruno/Arduino
1
0 Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

tft lib

Browse Source
This commit is contained in:
Tower committed 2026-04-12 13:04:48 +02:00
1 parent b462925b81
commit 81a242fbb8
86 files changed
+24419
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

libraries/Adafruit_TouchScreen/README.md
+26
View File
@@ -0,0 +1,26 @@
# Adafruit TouchScreen Library [![Build Status](https://github.com/adafruit/Adafruit_TouchScreen/workflows/Arduino%20Library%20CI/badge.svg)](https://github.com/adafruit/Adafruit_TouchScreen/actions)
This is the 4-wire resistive touch screen firmware for Arduino. Works with all Arduinos and Teensy
Adafruit invests time and resources providing this open source code, please support Adafruit and open-source hardware by purchasing products from Adafruit!
# Contributing
Contributions are welcome! Please read our [Code of Conduct](https://github.com/adafruit/Adafruit_TouchScreen/blob/master/CODE_OF_CONDUCT.md>)
before contributing to help this project stay welcoming.
## Documentation and doxygen
Documentation is produced by doxygen. Contributions should include documentation for any new code added.
Some examples of how to use doxygen can be found in these guide pages:
https://learn.adafruit.com/the-well-automated-arduino-library/doxygen
https://learn.adafruit.com/the-well-automated-arduino-library/doxygen-tips
Written by Limor Fried for Adafruit Industries.
BSD license, check license.txt for more information
All text above must be included in any redistribution
To install, use the Arduino Library Manager and search for "Adafruit TouchScreen" and install the library.
libraries/Adafruit_TouchScreen/TouchScreen.cpp
+291
View File
@@ -0,0 +1,291 @@
// Touch screen library with X Y and Z (pressure) readings as well
// as oversampling to avoid 'bouncing'
// (c) ladyada / adafruit
// Code under MIT License
#include "Arduino.h"
#include "pins_arduino.h"
#ifdef __AVR
#include <avr/pgmspace.h>
#elif defined(ESP8266)
#include <pgmspace.h>
#endif
#include "TouchScreen.h"
// increase or decrease the touchscreen oversampling. This is a little different
// than you make think: 1 is no oversampling, whatever data we get is
// immediately returned 2 is double-sampling and we only return valid data if
// both points are the same 3+ uses insert sort to get the median value. We
// found 2 is precise yet not too slow so we suggest sticking with it!
#define NUMSAMPLES 2
TSPoint::TSPoint(void) { x = y = z = 0; }
/**
* @brief Construct a new TSPoint::TSPoint object
*
* @param x0 The point's X value
* @param y0 The point's Y value
* @param z0 The point's Z value
*/
TSPoint::TSPoint(int16_t x0, int16_t y0, int16_t z0) {
x = x0;
y = y0;
z = z0;
}
/**
* @brief Check if the current point is equivalent to another point
*
* @param p1 The other point being checked for equivalence
* @return `true` : the two points are equivalent
* `false`: the two points are **not** equivalent
*/
bool TSPoint::operator==(TSPoint p1) {
return ((p1.x == x) && (p1.y == y) && (p1.z == z));
}
/**
* @brief Check if the current point is **not** equivalent to another point
*
* @param p1 The other point being checked for equivalence
* @return `true` :the two points are **not** equivalent
* `false`: the two points are equivalent
*/
bool TSPoint::operator!=(TSPoint p1) {
return ((p1.x != x) || (p1.y != y) || (p1.z != z));
}
#if (NUMSAMPLES > 2)
static void insert_sort(int array[], uint8_t size) {
uint8_t j;
int save;
for (int i = 1; i < size; i++) {
save = array[i];
for (j = i; j >= 1 && save < array[j - 1]; j--)
array[j] = array[j - 1];
array[j] = save;
}
}
#endif
/**
* @brief Measure the X, Y, and pressure and return a TSPoint with the
* measurements
*
* @return TSPoint The measured X, Y, and Z/pressure values
*/
TSPoint TouchScreen::getPoint(void) {
int x, y, z;
int samples[NUMSAMPLES];
uint8_t i, valid;
valid = 1;
pinMode(_yp, INPUT);
pinMode(_ym, INPUT);
pinMode(_xp, OUTPUT);
pinMode(_xm, OUTPUT);
#if defined(USE_FAST_PINIO)
*xp_port |= xp_pin;
*xm_port &= ~xm_pin;
#else
digitalWrite(_xp, HIGH);
digitalWrite(_xm, LOW);
#endif
#ifdef __arm__
delayMicroseconds(20); // Fast ARM chips need to allow voltages to settle
#endif
for (i = 0; i < NUMSAMPLES; i++) {
samples[i] = analogRead(_yp);
}
#if NUMSAMPLES > 2
insert_sort(samples, NUMSAMPLES);
#endif
#if NUMSAMPLES == 2
// Allow small amount of measurement noise, because capacitive
// coupling to a TFT display's signals can induce some noise.
if (samples[0] - samples[1] < -4 || samples[0] - samples[1] > 4) {
valid = 0;
} else {
samples[1] = (samples[0] + samples[1]) >> 1; // average 2 samples
}
#endif
x = (1023 - samples[NUMSAMPLES / 2]);
pinMode(_xp, INPUT);
pinMode(_xm, INPUT);
pinMode(_yp, OUTPUT);
pinMode(_ym, OUTPUT);
#if defined(USE_FAST_PINIO)
*ym_port &= ~ym_pin;
*yp_port |= yp_pin;
#else
digitalWrite(_ym, LOW);
digitalWrite(_yp, HIGH);
#endif
#ifdef __arm__
delayMicroseconds(20); // Fast ARM chips need to allow voltages to settle
#endif
for (i = 0; i < NUMSAMPLES; i++) {
samples[i] = analogRead(_xm);
}
#if NUMSAMPLES > 2
insert_sort(samples, NUMSAMPLES);
#endif
#if NUMSAMPLES == 2
// Allow small amount of measurement noise, because capacitive
// coupling to a TFT display's signals can induce some noise.
if (samples[0] - samples[1] < -4 || samples[0] - samples[1] > 4) {
valid = 0;
} else {
samples[1] = (samples[0] + samples[1]) >> 1; // average 2 samples
}
#endif
y = (1023 - samples[NUMSAMPLES / 2]);
// Set X+ to ground
// Set Y- to VCC
// Hi-Z X- and Y+
pinMode(_xp, OUTPUT);
pinMode(_yp, INPUT);
#if defined(USE_FAST_PINIO)
*xp_port &= ~xp_pin;
*ym_port |= ym_pin;
#else
digitalWrite(_xp, LOW);
digitalWrite(_ym, HIGH);
#endif
int z1 = analogRead(_xm);
int z2 = analogRead(_yp);
if (_rxplate != 0) {
// now read the x
float rtouch;
rtouch = z2;
rtouch /= z1;
rtouch -= 1;
rtouch *= x;
rtouch *= _rxplate;
rtouch /= 1024;
z = rtouch;
} else {
z = (1023 - (z2 - z1));
}
if (!valid) {
z = 0;
}
return TSPoint(x, y, z);
}
TouchScreen::TouchScreen(uint8_t xp, uint8_t yp, uint8_t xm, uint8_t ym,
uint16_t rxplate = 0) {
_yp = yp;
_xm = xm;
_ym = ym;
_xp = xp;
_rxplate = rxplate;
#if defined(USE_FAST_PINIO)
xp_port = portOutputRegister(digitalPinToPort(_xp));
yp_port = portOutputRegister(digitalPinToPort(_yp));
xm_port = portOutputRegister(digitalPinToPort(_xm));
ym_port = portOutputRegister(digitalPinToPort(_ym));
xp_pin = digitalPinToBitMask(_xp);
yp_pin = digitalPinToBitMask(_yp);
xm_pin = digitalPinToBitMask(_xm);
ym_pin = digitalPinToBitMask(_ym);
#endif
pressureThreshhold = 10;
}
/**
* @brief Read the touch event's X value
*
* @return int the X measurement
*/
int TouchScreen::readTouchX(void) {
pinMode(_yp, INPUT);
pinMode(_ym, INPUT);
digitalWrite(_yp, LOW);
digitalWrite(_ym, LOW);
pinMode(_xp, OUTPUT);
digitalWrite(_xp, HIGH);
pinMode(_xm, OUTPUT);
digitalWrite(_xm, LOW);
return (1023 - analogRead(_yp));
}
/**
* @brief Read the touch event's Y value
*
* @return int the Y measurement
*/
int TouchScreen::readTouchY(void) {
pinMode(_xp, INPUT);
pinMode(_xm, INPUT);
digitalWrite(_xp, LOW);
digitalWrite(_xm, LOW);
pinMode(_yp, OUTPUT);
digitalWrite(_yp, HIGH);
pinMode(_ym, OUTPUT);
digitalWrite(_ym, LOW);
return (1023 - analogRead(_xm));
}
/**
* @brief Read the touch event's Z/pressure value
*
* @return int the Z measurement
*/
uint16_t TouchScreen::pressure(void) {
// Set X+ to ground
pinMode(_xp, OUTPUT);
digitalWrite(_xp, LOW);
// Set Y- to VCC
pinMode(_ym, OUTPUT);
digitalWrite(_ym, HIGH);
// Hi-Z X- and Y+
digitalWrite(_xm, LOW);
pinMode(_xm, INPUT);
digitalWrite(_yp, LOW);
pinMode(_yp, INPUT);
int z1 = analogRead(_xm);
int z2 = analogRead(_yp);
if (_rxplate != 0) {
// now read the x
float rtouch;
rtouch = z2;
rtouch /= z1;
rtouch -= 1;
rtouch *= readTouchX();
rtouch *= _rxplate;
rtouch /= 1024;
return rtouch;
} else {
return (1023 - (z2 - z1));
}
}
libraries/Adafruit_TouchScreen/TouchScreen.h
+80
View File
@@ -0,0 +1,80 @@
// Touch screen library with X Y and Z (pressure) readings as well
// as oversampling to avoid 'bouncing'
// (c) ladyada / adafruit
// Code under MIT License
#ifndef _ADAFRUIT_TOUCHSCREEN_H_
#define _ADAFRUIT_TOUCHSCREEN_H_
#include <stdint.h>
#if (defined(__AVR_ATmega328P__) || defined(__AVR_ATmega32U4__) || \
defined(TEENSYDUINO) || defined(__AVR_ATmega2560__) || \
defined(__AVR_ATmega4809__)) && \
!defined(__IMXRT1062__)
typedef volatile uint8_t RwReg;
#elif defined(ARDUINO_STM32_FEATHER)
typedef volatile uint32 RwReg;
#elif defined(NRF52_SERIES) || defined(ESP32) || defined(ESP8266) || \
defined(ARDUINO_ARCH_STM32) || defined(__IMXRT1062__)
typedef volatile uint32_t RwReg;
#else
typedef volatile uint32_t RwReg;
#endif
#if defined(__AVR__) || defined(TEENSYDUINO) || defined(ARDUINO_ARCH_SAMD)
#define USE_FAST_PINIO
#endif
/** Object that encapsulates the X,Y, and Z/pressure measurements for a touch
* event. */
class TSPoint {
public:
TSPoint(void);
TSPoint(int16_t x, int16_t y, int16_t z);
bool operator==(TSPoint);
bool operator!=(TSPoint);
int16_t x, ///< state variable for the x value
y, ///< state variable for the y value
z; ///< state variable for the z value
};
/** Object that controls and keeps state for a touch screen. */
class TouchScreen {
public:
/**
* @brief Construct a new Touch Screen object
*
* @param xp X+ pin. Must be an analog pin
* @param yp Y+ pin. Must be an analog pin
* @param xm X- pin. Can be a digital pin
* @param ym Y- pin. Can be a digital pin
* @param rx The resistance in ohms between X+ and X- to calibrate pressure
* sensing
*/
TouchScreen(uint8_t xp, uint8_t yp, uint8_t xm, uint8_t ym, uint16_t rx);
/**
* @brief **NOT IMPLEMENTED** Test if the screen has been touched
*
* @return true : touch detected false: no touch detected
*/
bool isTouching(void);
uint16_t pressure(void);
int readTouchY();
int readTouchX();
TSPoint getPoint();
int16_t pressureThreshhold; ///< Pressure threshold for `isTouching`
private:
uint8_t _yp, _ym, _xm, _xp;
uint16_t _rxplate;
#if defined(USE_FAST_PINIO)
volatile RwReg *xp_port, *yp_port, *xm_port, *ym_port;
RwReg xp_pin, xm_pin, yp_pin, ym_pin;
#endif
};
#endif
libraries/Adafruit_TouchScreen/code-of-conduct.md
+127
View File
@@ -0,0 +1,127 @@
# Adafruit Community Code of Conduct
## Our Pledge
In the interest of fostering an open and welcoming environment, we as
contributors and leaders pledge to making participation in our project and
our community a harassment-free experience for everyone, regardless of age, body
size, disability, ethnicity, gender identity and expression, level or type of
experience, education, socio-economic status, nationality, personal appearance,
race, religion, or sexual identity and orientation.
## Our Standards
We are committed to providing a friendly, safe and welcoming environment for
all.
Examples of behavior that contributes to creating a positive environment
include:
* Be kind and courteous to others
* Using welcoming and inclusive language
* Being respectful of differing viewpoints and experiences
* Collaborating with other community members
* Gracefully accepting constructive criticism
* Focusing on what is best for the community
* Showing empathy towards other community members
Examples of unacceptable behavior by participants include:
* The use of sexualized language or imagery and sexual attention or advances
* The use of inappropriate images, including in a community member's avatar
* The use of inappropriate language, including in a community member's nickname
* Any spamming, flaming, baiting or other attention-stealing behavior
* Excessive or unwelcome helping; answering outside the scope of the question
asked
* Trolling, insulting/derogatory comments, and personal or political attacks
* Public or private harassment
* Publishing others' private information, such as a physical or electronic
address, without explicit permission
* Other conduct which could reasonably be considered inappropriate
The goal of the standards and moderation guidelines outlined here is to build
and maintain a respectful community. We ask that you don’t just aim to be
"technically unimpeachable", but rather try to be your best self.
We value many things beyond technical expertise, including collaboration and
supporting others within our community. Providing a positive experience for
other community members can have a much more significant impact than simply
providing the correct answer.
## Our Responsibilities
Project leaders are responsible for clarifying the standards of acceptable
behavior and are expected to take appropriate and fair corrective action in
response to any instances of unacceptable behavior.
Project leaders have the right and responsibility to remove, edit, or
reject messages, comments, commits, code, issues, and other contributions
that are not aligned to this Code of Conduct, or to ban temporarily or
permanently any community member for other behaviors that they deem
inappropriate, threatening, offensive, or harmful.
## Moderation
Instances of behaviors that violate the Adafruit Community Code of Conduct
may be reported by any member of the community. Community members are
encouraged to report these situations, including situations they witness
involving other community members.
You may report in the following ways:
In any situation, you may send an email to <support@adafruit.com>.
On the Adafruit Discord, you may send an open message from any channel
to all Community Helpers by tagging @community helpers. You may also send an
open message from any channel, or a direct message to @kattni#1507,
@tannewt#4653, @Dan Halbert#1614, @cater#2442, @sommersoft#0222, or
@Andon#8175.
Email and direct message reports will be kept confidential.
In situations on Discord where the issue is particularly egregious, possibly
illegal, requires immediate action, or violates the Discord terms of service,
you should also report the message directly to Discord.
These are the steps for upholding our community’s standards of conduct.
1. Any member of the community may report any situation that violates the
Adafruit Community Code of Conduct. All reports will be reviewed and
investigated.
2. If the behavior is an egregious violation, the community member who
committed the violation may be banned immediately, without warning.
3. Otherwise, moderators will first respond to such behavior with a warning.
4. Moderators follow a soft "three strikes" policy - the community member may
be given another chance, if they are receptive to the warning and change their
behavior.
5. If the community member is unreceptive or unreasonable when warned by a
moderator, or the warning goes unheeded, they may be banned for a first or
second offense. Repeated offenses will result in the community member being
banned.
## Scope
This Code of Conduct and the enforcement policies listed above apply to all
Adafruit Community venues. This includes but is not limited to any community
spaces (both public and private), the entire Adafruit Discord server, and
Adafruit GitHub repositories. Examples of Adafruit Community spaces include
but are not limited to meet-ups, audio chats on the Adafruit Discord, or
interaction at a conference.
This Code of Conduct applies both within project spaces and in public spaces
when an individual is representing the project or its community. As a community
member, you are representing our community, and are expected to behave
accordingly.
## Attribution
This Code of Conduct is adapted from the [Contributor Covenant][homepage],
version 1.4, available at
<https://www.contributor-covenant.org/version/1/4/code-of-conduct.html>,
and the [Rust Code of Conduct](https://www.rust-lang.org/en-US/conduct.html).
For other projects adopting the Adafruit Community Code of
Conduct, please contact the maintainers of those projects for enforcement.
If you wish to use this code of conduct for your own project, consider
explicitly mentioning your moderation policy or making a copy with your
own moderation policy so as to avoid confusion.
libraries/Adafruit_TouchScreen/examples/touchscreendemo/touchscreendemo.ino
+40
View File
@@ -0,0 +1,40 @@
// Touch screen library with X Y and Z (pressure) readings as well
// as oversampling to avoid 'bouncing'
// This demo code returns raw readings, public domain
#include <stdint.h>
#include "TouchScreen.h"
#define YP A2 // must be an analog pin, use "An" notation!
#define XM A3 // must be an analog pin, use "An" notation!
#define YM 8 // can be a digital pin
#define XP 9 // can be a digital pin
// For better pressure precision, we need to know the resistance
// between X+ and X- Use any multimeter to read it
// For the one we're using, its 300 ohms across the X plate
TouchScreen ts = TouchScreen(XP, YP, XM, YM, 300);
void setup(void) {
Serial.begin(9600);
// 10 bit ADC values are expected by the touch library.
// If touch locations seem incorrect, try uncommenting
// this line to force 10 bit resolution:
// analogReadResolution(10);
}
void loop(void) {
// a point object holds x y and z coordinates
TSPoint p = ts.getPoint();
// we have some minimum pressure we consider 'valid'
// pressure of 0 means no pressing!
if (p.z > ts.pressureThreshhold) {
Serial.print("X = "); Serial.print(p.x);
Serial.print("\tY = "); Serial.print(p.y);
Serial.print("\tPressure = "); Serial.println(p.z);
}
delay(100);
}
libraries/Adafruit_TouchScreen/examples/touchscreendemoshield/touchscreendemoshield.ino
+42
View File
@@ -0,0 +1,42 @@
// Touch screen library with X Y and Z (pressure) readings as well
// as oversampling to avoid 'bouncing'
// This demo code returns raw readings, public domain
#include <stdint.h>
#include "TouchScreen.h"
// These are the pins for the shield!
#define YP A1 // must be an analog pin, use "An" notation!
#define XM A2 // must be an analog pin, use "An" notation!
#define YM 7 // can be a digital pin
#define XP 6 // can be a digital pin
#define MINPRESSURE 10
#define MAXPRESSURE 1000
// For better pressure precision, we need to know the resistance
// between X+ and X- Use any multimeter to read it
// For the one we're using, its 300 ohms across the X plate
TouchScreen ts = TouchScreen(XP, YP, XM, YM, 300);
void setup(void) {
Serial.begin(9600);
// 10 bit ADC values are expected by the touch library.
// If touch locations seem incorrect, try uncommenting
// this line to force 10 bit resolution:
// analogReadResolution(10);
}
void loop(void) {
// a point object holds x y and z coordinates
TSPoint p = ts.getPoint();
// we have some minimum pressure we consider 'valid'
// pressure of 0 means no pressing!
if (p.z > MINPRESSURE && p.z < MAXPRESSURE) {
Serial.print("X = "); Serial.print(p.x);
Serial.print("\tY = "); Serial.print(p.y);
Serial.print("\tPressure = "); Serial.println(p.z);
}
}
libraries/Adafruit_TouchScreen/library.properties
+9
View File
@@ -0,0 +1,9 @@
name=Adafruit TouchScreen
version=1.1.6
author=Adafruit
maintainer=Adafruit <info@adafruit.com>
sentence=Adafruit TouchScreen display library.
paragraph=Adafruit TouchScreen display library.
category=Display
url=https://github.com/adafruit/Adafruit_TouchScreen
architectures=*
libraries/Adafruit_TouchScreen/license.txt
+26
View File
@@ -0,0 +1,26 @@
Software License Agreement (BSD License)
Copyright (c) 2019 Limor Fried for Adafruit Industries
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
1. Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
3. Neither the name of the copyright holders nor the
names of its contributors may be used to endorse or promote products
derived from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ''AS IS'' AND ANY
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
libraries/MCUFRIEND_kbv/FreeDefaultFonts.h
+725
View File
@@ -0,0 +1,725 @@
// generate FreeFont from UTFT font
const uint8_t FreeSmallFontBitmaps[] PROGMEM = {
// 0x0 [0x20 '.']
// 1x8 [0x21 '!']
0xFD,
// 4x3 [0x22 '"']
0x5A,0xA0,
// 6x8 [0x23 '#']
0x28,0xAF,0xCA,0x53,0xF5,0x14,
// 5x10 [0x24 '$']
0x23,0xEB,0x46,0x18,0xB5,0xF1,0x00,
// 6x8 [0x25 '%']
0x4A,0xAB,0x14,0x28,0xD5,0x52,
// 6x8 [0x26 '&']
0x21,0x45,0x1E,0xAA,0xA9,0x1B,
// 2x3 [0x27 ''']
0x58,
// 3x10 [0x28 '(']
0x2A,0x49,0x24,0x44,
// 3x10 [0x29 ')']
0x88,0x92,0x49,0x50,
// 5x6 [0x2A '*']
0x25,0x5C,0xEA,0x90,
// 5x7 [0x2B '+']
0x21,0x09,0xF2,0x10,0x80,
// 2x3 [0x2C ',']
0x58,
// 5x1 [0x2D '-']
0xF8,
// 1x1 [0x2E '.']
0x80,
// 5x10 [0x2F '/']
0x08,0x84,0x22,0x11,0x08,0x44,0x00,
// 5x8 [0x30 '0']
0x74,0x63,0x18,0xC6,0x2E,
// 3x8 [0x31 '1']
0x59,0x24,0x97,
// 5x8 [0x32 '2']
0x74,0x62,0x22,0x22,0x1F,
// 5x8 [0x33 '3']
0x74,0x42,0x60,0x86,0x2E,
// 5x8 [0x34 '4']
0x11,0x94,0xA9,0x3C,0x43,
// 5x8 [0x35 '5']
0xFC,0x21,0xE0,0x86,0x2E,
// 5x8 [0x36 '6']
0x74,0xA1,0xE8,0xC6,0x2E,
// 5x8 [0x37 '7']
0xFC,0x84,0x42,0x10,0x84,
// 5x8 [0x38 '8']
0x74,0x62,0xE8,0xC6,0x2E,
// 5x8 [0x39 '9']
0x74,0x63,0x17,0x85,0x2E,
// 1x6 [0x3A ':']
0x84,
// 1x6 [0x3B ';']
0x8C,
// 5x9 [0x3C '<']
0x08,0x88,0x88,0x20,0x82,0x08,
// 5x4 [0x3D '=']
0xF8,0x01,0xF0,
// 5x9 [0x3E '>']
0x82,0x08,0x20,0x88,0x88,0x80,
// 5x8 [0x3F '?']
0x74,0x62,0x22,0x10,0x04,
// 5x8 [0x40 '@']
0x74,0x67,0x5A,0xDE,0x0F,
// 6x8 [0x41 'A']
0x20,0x83,0x14,0x51,0xE4,0xB3,
// 5x8 [0x42 'B']
0xF2,0x52,0xE4,0xA5,0x3E,
// 5x8 [0x43 'C']
0x7C,0x61,0x08,0x42,0x2E,
// 5x8 [0x44 'D']
0xF2,0x52,0x94,0xA5,0x3E,
// 5x8 [0x45 'E']
0xFA,0x54,0xE5,0x21,0x3F,
// 5x8 [0x46 'F']
0xFA,0x54,0xE5,0x21,0x1C,
// 6x8 [0x47 'G']
0x39,0x28,0x20,0x9E,0x24,0x8C,
// 6x8 [0x48 'H']
0xCD,0x24,0x9E,0x49,0x24,0xB3,
// 5x8 [0x49 'I']
0xF9,0x08,0x42,0x10,0x9F,
// 6x9 [0x4A 'J']
0x7C,0x41,0x04,0x10,0x41,0x24,0xE0,
// 6x8 [0x4B 'K']
0xED,0x25,0x18,0x51,0x44,0xBB,
// 6x8 [0x4C 'L']
0xE1,0x04,0x10,0x41,0x04,0x7F,
// 5x8 [0x4D 'M']
0xDE,0xF7,0xBA,0xD6,0xB5,
// 6x8 [0x4E 'N']
0xDD,0x26,0x9A,0x59,0x64,0xBA,
// 5x8 [0x4F 'O']
0x74,0x63,0x18,0xC6,0x2E,
// 5x8 [0x50 'P']
0xF2,0x52,0xE4,0x21,0x1C,
// 5x9 [0x51 'Q']
0x74,0x63,0x18,0xF6,0x6E,0x18,
// 6x8 [0x52 'R']
0xF1,0x24,0x9C,0x51,0x24,0xBB,
// 5x8 [0x53 'S']
0x7C,0x60,0xC1,0x06,0x3E,
// 5x8 [0x54 'T']
0xFD,0x48,0x42,0x10,0x8E,
// 6x8 [0x55 'U']
0xCD,0x24,0x92,0x49,0x24,0x8C,
// 6x8 [0x56 'V']
0xCD,0x24,0x94,0x50,0xC2,0x08,
// 5x8 [0x57 'W']
0xAD,0x6A,0xE5,0x29,0x4A,
// 5x8 [0x58 'X']
0xDA,0x94,0x42,0x29,0x5B,
// 5x8 [0x59 'Y']
0xDA,0x94,0x42,0x10,0x8E,
// 5x8 [0x5A 'Z']
0xFC,0x84,0x42,0x21,0x3F,
// 3x10 [0x5B '[']
0xF2,0x49,0x24,0x9C,
// 4x9 [0x5C '\']
0x88,0x84,0x42,0x22,0x10,
// 3x10 [0x5D ']']
0xE4,0x92,0x49,0x3C,
// 3x2 [0x5E '^']
0x54,
// 6x1 [0x5F '_']
0xFC,
// 1x1 [0x60 '`']
0x80,
// 5x5 [0x61 'a']
0x64,0x9D,0x27,0x80,
// 5x8 [0x62 'b']
0xC2,0x10,0xE4,0xA5,0x2E,
// 4x5 [0x63 'c']
0x79,0x88,0x70,
// 5x8 [0x64 'd']
0x30,0x84,0xE9,0x4A,0x4F,
// 4x5 [0x65 'e']
0x69,0xF8,0x70,
// 5x8 [0x66 'f']
0x3A,0x11,0xE4,0x21,0x1E,
// 5x7 [0x67 'g']
0x7C,0x99,0x0F,0x45,0xC0,
// 6x8 [0x68 'h']
0xC1,0x04,0x1C,0x49,0x24,0xBB,
// 3x8 [0x69 'i']
0x40,0x64,0x97,
// 4x10 [0x6A 'j']
0x10,0x03,0x11,0x11,0x1E,
// 6x8 [0x6B 'k']
0xC1,0x04,0x17,0x51,0xC4,0xBB,
// 5x8 [0x6C 'l']
0xE1,0x08,0x42,0x10,0x9F,
// 5x5 [0x6D 'm']
0xF5,0x6B,0x5A,0x80,
// 6x5 [0x6E 'n']
0xF1,0x24,0x92,0xEC,
// 4x5 [0x6F 'o']
0x69,0x99,0x60,
// 5x7 [0x70 'p']
0xF2,0x52,0x97,0x23,0x80,
// 5x7 [0x71 'q']
0x74,0xA5,0x27,0x08,0xE0,
// 5x5 [0x72 'r']
0xDB,0x10,0x8E,0x00,
// 4x5 [0x73 's']
0xF8,0x61,0xF0,
// 4x7 [0x74 't']
0x44,0xE4,0x44,0x30,
// 6x5 [0x75 'u']
0xD9,0x24,0x92,0x3C,
// 6x5 [0x76 'v']
0xED,0x25,0x0C,0x20,
// 5x5 [0x77 'w']
0xAD,0x5C,0xA5,0x00,
// 5x5 [0x78 'x']
0xDA,0x88,0xAD,0x80,
// 6x7 [0x79 'y']
0xED,0x25,0x0C,0x20,0x8C,0x00,
// 4x5 [0x7A 'z']
0xF2,0x44,0xF0,
// 3x10 [0x7B '{']
0x69,0x28,0x92,0x4C,
// 1x12 [0x7C '|']
0xFF,0xF0,
// 3x10 [0x7D '}']
0xC9,0x22,0x92,0x58,
// 6x3 [0x7E '~']
0x42,0x91,0x80,
};
const GFXglyph FreeSmallFontGlyphs[] PROGMEM = {
{ 0, 0, 0, 8, 8, -12 }, // 0x20 ' '
{ 0, 1, 8, 8, 2, -10 }, // 0x21 '!'
{ 1, 4, 3, 8, 1, -11 }, // 0x22 '"'
{ 3, 6, 8, 8, 0, -10 }, // 0x23 '#'
{ 9, 5, 10, 8, 0, -11 }, // 0x24 '$'
{ 16, 6, 8, 8, 0, -10 }, // 0x25 '%'
{ 22, 6, 8, 8, 0, -10 }, // 0x26 '&'
{ 28, 2, 3, 8, 0, -11 }, // 0x27 '''
{ 29, 3, 10, 8, 3, -11 }, // 0x28 '('
{ 33, 3, 10, 8, 1, -11 }, // 0x29 ')'
{ 37, 5, 6, 8, 0, -9 }, // 0x2A '*'
{ 41, 5, 7, 8, 0, -10 }, // 0x2B '+'
{ 46, 2, 3, 8, 0, -3 }, // 0x2C ','
{ 47, 5, 1, 8, 0, -7 }, // 0x2D '-'
{ 48, 1, 1, 8, 1, -3 }, // 0x2E '.'
{ 49, 5, 10, 8, 0, -11 }, // 0x2F '/'
{ 56, 5, 8, 8, 0, -10 }, // 0x30 '0'
{ 61, 3, 8, 8, 1, -10 }, // 0x31 '1'
{ 64, 5, 8, 8, 0, -10 }, // 0x32 '2'
{ 69, 5, 8, 8, 0, -10 }, // 0x33 '3'
{ 74, 5, 8, 8, 0, -10 }, // 0x34 '4'
{ 79, 5, 8, 8, 0, -10 }, // 0x35 '5'
{ 84, 5, 8, 8, 0, -10 }, // 0x36 '6'
{ 89, 5, 8, 8, 0, -10 }, // 0x37 '7'
{ 94, 5, 8, 8, 0, -10 }, // 0x38 '8'
{ 99, 5, 8, 8, 0, -10 }, // 0x39 '9'
{ 104, 1, 6, 8, 2, -8 }, // 0x3A ':'
{ 105, 1, 6, 8, 2, -7 }, // 0x3B ';'
{ 106, 5, 9, 8, 1, -11 }, // 0x3C '<'
{ 112, 5, 4, 8, 0, -8 }, // 0x3D '='
{ 115, 5, 9, 8, 1, -11 }, // 0x3E '>'
{ 121, 5, 8, 8, 0, -10 }, // 0x3F '?'
{ 126, 5, 8, 8, 0, -10 }, // 0x40 '@'
{ 131, 6, 8, 8, 0, -10 }, // 0x41 'A'
{ 137, 5, 8, 8, 0, -10 }, // 0x42 'B'
{ 142, 5, 8, 8, 0, -10 }, // 0x43 'C'
{ 147, 5, 8, 8, 0, -10 }, // 0x44 'D'
{ 152, 5, 8, 8, 0, -10 }, // 0x45 'E'
{ 157, 5, 8, 8, 0, -10 }, // 0x46 'F'
{ 162, 6, 8, 8, 0, -10 }, // 0x47 'G'
{ 168, 6, 8, 8, 0, -10 }, // 0x48 'H'
{ 174, 5, 8, 8, 0, -10 }, // 0x49 'I'
{ 179, 6, 9, 8, 0, -10 }, // 0x4A 'J'
{ 186, 6, 8, 8, 0, -10 }, // 0x4B 'K'
{ 192, 6, 8, 8, 0, -10 }, // 0x4C 'L'
{ 198, 5, 8, 8, 0, -10 }, // 0x4D 'M'
{ 203, 6, 8, 8, 0, -10 }, // 0x4E 'N'
{ 209, 5, 8, 8, 0, -10 }, // 0x4F 'O'
{ 214, 5, 8, 8, 0, -10 }, // 0x50 'P'
{ 219, 5, 9, 8, 0, -10 }, // 0x51 'Q'
{ 225, 6, 8, 8, 0, -10 }, // 0x52 'R'
{ 231, 5, 8, 8, 0, -10 }, // 0x53 'S'
{ 236, 5, 8, 8, 0, -10 }, // 0x54 'T'
{ 241, 6, 8, 8, 0, -10 }, // 0x55 'U'
{ 247, 6, 8, 8, 0, -10 }, // 0x56 'V'
{ 253, 5, 8, 8, 0, -10 }, // 0x57 'W'
{ 258, 5, 8, 8, 0, -10 }, // 0x58 'X'
{ 263, 5, 8, 8, 0, -10 }, // 0x59 'Y'
{ 268, 5, 8, 8, 0, -10 }, // 0x5A 'Z'
{ 273, 3, 10, 8, 2, -11 }, // 0x5B '['
{ 277, 4, 9, 8, 1, -11 }, // 0x5C '\'
{ 282, 3, 10, 8, 1, -11 }, // 0x5D ']'
{ 286, 3, 2, 8, 1, -11 }, // 0x5E '^'
{ 287, 6, 1, 8, 0, -1 }, // 0x5F '_'
{ 288, 1, 1, 8, 2, -11 }, // 0x60 '`'
{ 289, 5, 5, 8, 1, -7 }, // 0x61 'a'
{ 293, 5, 8, 8, 0, -10 }, // 0x62 'b'
{ 298, 4, 5, 8, 1, -7 }, // 0x63 'c'
{ 301, 5, 8, 8, 1, -10 }, // 0x64 'd'
{ 306, 4, 5, 8, 1, -7 }, // 0x65 'e'
{ 309, 5, 8, 8, 1, -10 }, // 0x66 'f'
{ 314, 5, 7, 8, 1, -7 }, // 0x67 'g'
{ 319, 6, 8, 8, 0, -10 }, // 0x68 'h'
{ 325, 3, 8, 8, 1, -10 }, // 0x69 'i'
{ 328, 4, 10, 8, 0, -10 }, // 0x6A 'j'
{ 333, 6, 8, 8, 0, -10 }, // 0x6B 'k'
{ 339, 5, 8, 8, 0, -10 }, // 0x6C 'l'
{ 344, 5, 5, 8, 0, -7 }, // 0x6D 'm'
{ 348, 6, 5, 8, 0, -7 }, // 0x6E 'n'
{ 352, 4, 5, 8, 1, -7 }, // 0x6F 'o'
{ 355, 5, 7, 8, 0, -7 }, // 0x70 'p'
{ 360, 5, 7, 8, 1, -7 }, // 0x71 'q'
{ 365, 5, 5, 8, 0, -7 }, // 0x72 'r'
{ 369, 4, 5, 8, 1, -7 }, // 0x73 's'
{ 372, 4, 7, 8, 1, -9 }, // 0x74 't'
{ 376, 6, 5, 8, 0, -7 }, // 0x75 'u'
{ 380, 6, 5, 8, 0, -7 }, // 0x76 'v'
{ 384, 5, 5, 8, 0, -7 }, // 0x77 'w'
{ 388, 5, 5, 8, 0, -7 }, // 0x78 'x'
{ 392, 6, 7, 8, 0, -7 }, // 0x79 'y'
{ 398, 4, 5, 8, 1, -7 }, // 0x7A 'z'
{ 401, 3, 10, 8, 2, -11 }, // 0x7B '{'
{ 405, 1, 12, 8, 3, -12 }, // 0x7C '|'
{ 407, 3, 10, 8, 1, -11 }, // 0x7D '}'
{ 411, 6, 3, 8, 0, -12 }, // 0x7E '~'
};
const GFXfont FreeSmallFont PROGMEM = {
(uint8_t *)FreeSmallFontBitmaps,
(GFXglyph *)FreeSmallFontGlyphs,
32, 126, 12
};
// FreeSmallFont bitmap size = 414 [1079] [1239]
const uint8_t FreeBigFontBitmaps[] PROGMEM = {
// 0x0 [0x20 '.']
// 5x13 [0x21 '!']
0x77,0xFF,0xFF,0xFD,0xCE,0x00,0x1C,0xE7,0x00,
// 9x5 [0x22 '"']
0xE3,0xF1,0xF8,0xFC,0x76,0x30,
// 14x14 [0x23 '#']
0x18,0x60,0x61,0x81,0x86,0x3F,0xFF,0xFF,0xFC,0x61,0x81,0x86,0x06,0x18,0x18,0x63,
0xFF,0xFF,0xFF,0xC6,0x18,0x18,0x60,0x61,0x80,
// 10x14 [0x24 '$']
0x12,0x04,0x87,0xFF,0xFF,0xD2,0x34,0x8F,0xF9,0xFF,0x12,0xC4,0xBF,0xFF,0xFE,0x12,
0x04,0x80,
// 8x10 [0x25 '%']
0xE1,0xE3,0xE7,0x0E,0x1C,0x38,0x70,0xE7,0xC7,0x87,
// 10x12 [0x26 '&']
0x78,0x33,0x0C,0xC3,0x30,0x78,0x1E,0x17,0xCF,0x3F,0xC7,0xB1,0xCC,0xF9,0xF3,
// 4x4 [0x27 ''']
0x77,0x7E,
// 8x12 [0x28 '(']
0x0F,0x1C,0x38,0x70,0xE0,0xE0,0xE0,0xE0,0x70,0x38,0x1C,0x0F,
// 8x12 [0x29 ')']
0xF0,0x38,0x1C,0x0E,0x07,0x07,0x07,0x07,0x0E,0x1C,0x38,0xF0,
// 12x12 [0x2A '*']
0x06,0x04,0x62,0x26,0x41,0xF8,0x1F,0x8F,0xFF,0xFF,0xF1,0xF8,0x1F,0x82,0x64,0x46,
0x20,0x60,
// 8x8 [0x2B '+']
0x18,0x18,0x18,0xFF,0xFF,0x18,0x18,0x18,
// 4x4 [0x2C ',']
0x77,0x7E,
// 10x2 [0x2D '-']
0xFF,0xFF,0xF0,
// 3x3 [0x2E '.']
0xFF,0x80,
// 12x12 [0x2F '/']
0x00,0x10,0x03,0x00,0x70,0x0E,0x01,0xC0,0x38,0x07,0x00,0xE0,0x1C,0x03,0x80,0x70,
0x0E,0x00,
// 10x12 [0x30 '0']
0x7F,0xB8,0x7E,0x3F,0x9F,0xE7,0xFB,0x7E,0xDF,0xE7,0xF9,0xFC,0x7E,0x1D,0xFE,
// 9x12 [0x31 '1']
0x0C,0x06,0x07,0x1F,0x8F,0xC0,0xE0,0x70,0x38,0x1C,0x0E,0x07,0x1F,0xF0,
// 10x12 [0x32 '2']
0x7F,0x38,0xEE,0x1C,0x07,0x03,0x81,0xC0,0xE0,0x70,0x38,0x1C,0x7E,0x1F,0xFF,
// 10x12 [0x33 '3']
0x7F,0x38,0xEE,0x1C,0x07,0x03,0x87,0x81,0xE0,0x0E,0x01,0xF8,0x7E,0x39,0xFC,
// 10x12 [0x34 '4']
0x07,0x03,0xC1,0xF0,0xDC,0x67,0x31,0xCF,0xFF,0xFF,0x07,0x01,0xC0,0x70,0x7F,
// 10x12 [0x35 '5']
0xFF,0xF8,0x0E,0x03,0x80,0xE0,0x3F,0xCF,0xF8,0x0F,0x01,0xF8,0x7E,0x39,0xFC,
// 10x12 [0x36 '6']
0x1F,0x0E,0x07,0x03,0x80,0xE0,0x3F,0xEF,0xFF,0x87,0xE1,0xF8,0x7E,0x1D,0xFE,
// 11x12 [0x37 '7']
0xFF,0xFC,0x1F,0x83,0xF0,0x70,0x0E,0x03,0x80,0xE0,0x38,0x0E,0x03,0x80,0x70,0x0E,
0x00,
// 10x12 [0x38 '8']
0x7F,0xB8,0x7E,0x1F,0x87,0xF9,0xCF,0xC3,0xF3,0x9F,0xE1,0xF8,0x7E,0x1D,0xFE,
// 10x12 [0x39 '9']
0x7F,0xB8,0x7E,0x1F,0x87,0xE1,0xFF,0xF7,0xFC,0x07,0x01,0xC0,0xE0,0x70,0xF8,
// 3x8 [0x3A ':']
0xFF,0x81,0xFF,
// 4x9 [0x3B ';']
0x77,0x70,0x07,0x77,0xE0,
// 9x14 [0x3C '<']
0x03,0x83,0x83,0x83,0x83,0x83,0x83,0x81,0xC0,0x70,0x1C,0x07,0x01,0xC0,0x70,0x1C,
// 12x6 [0x3D '=']
0xFF,0xFF,0xFF,0x00,0x00,0x00,0xFF,0xFF,0xFF,
// 9x14 [0x3E '>']
0xE0,0x38,0x0E,0x03,0x80,0xE0,0x38,0x0E,0x07,0x07,0x07,0x07,0x07,0x07,0x07,0x00,
// 10x14 [0x3F '?']
0x1E,0x1F,0xEF,0x3F,0x07,0x01,0xC0,0xE0,0x70,0x38,0x0E,0x00,0x00,0x00,0x38,0x0E,
0x03,0x80,
// 11x14 [0x40 '@']
0x7F,0xDC,0x1F,0x83,0xF0,0x7E,0x0F,0xCF,0xF9,0xFF,0x3F,0xE7,0xFC,0x03,0x80,0x70,
0x0F,0xF8,0x7F,0x80,
// 10x12 [0x41 'A']
0x1E,0x0F,0xC7,0x3B,0x87,0xE1,0xF8,0x7E,0x1F,0xFF,0xE1,0xF8,0x7E,0x1F,0x87,
// 10x12 [0x42 'B']
0xFF,0x9C,0x77,0x1D,0xC7,0x71,0xDF,0xE7,0xF9,0xC7,0x71,0xDC,0x77,0x1F,0xFE,
// 10x12 [0x43 'C']
0x3F,0x9C,0x7E,0x1F,0x80,0xE0,0x38,0x0E,0x03,0x80,0xE0,0x38,0x77,0x1C,0xFE,
// 10x12 [0x44 'D']
0xFF,0x1C,0xE7,0x1D,0xC7,0x71,0xDC,0x77,0x1D,0xC7,0x71,0xDC,0x77,0x3B,0xFC,
// 10x12 [0x45 'E']
0xFF,0xDC,0x37,0x05,0xC0,0x71,0x9F,0xE7,0xF9,0xC6,0x70,0x1C,0x17,0x0F,0xFF,
// 10x12 [0x46 'F']
0xFF,0xDC,0x37,0x05,0xC0,0x71,0x9F,0xE7,0xF9,0xC6,0x70,0x1C,0x07,0x03,0xE0,
// 10x12 [0x47 'G']
0x3F,0x9C,0x7E,0x1F,0x87,0xE0,0x38,0x0E,0x03,0x9F,0xE1,0xF8,0x77,0x1C,0xFF,
// 9x12 [0x48 'H']
0xE3,0xF1,0xF8,0xFC,0x7E,0x3F,0xFF,0xFF,0xC7,0xE3,0xF1,0xF8,0xFC,0x70,
// 7x12 [0x49 'I']
0xFE,0x70,0xE1,0xC3,0x87,0x0E,0x1C,0x38,0x70,0xE7,0xF0,
// 12x12 [0x4A 'J']
0x07,0xF0,0x1C,0x01,0xC0,0x1C,0x01,0xC0,0x1C,0x01,0xCE,0x1C,0xE1,0xCE,0x1C,0xE1,
0xC3,0xF8,
// 10x12 [0x4B 'K']
0xF1,0xDC,0x77,0x39,0xDC,0x7E,0x1F,0x07,0xC1,0xF8,0x77,0x1C,0xE7,0x1F,0xC7,
// 10x12 [0x4C 'L']
0xF8,0x1C,0x07,0x01,0xC0,0x70,0x1C,0x07,0x01,0xC0,0x70,0x5C,0x37,0x1F,0xFF,
// 11x12 [0x4D 'M']
0xE0,0xFE,0x3F,0xEF,0xFF,0xFF,0xFF,0xDD,0xF9,0x3F,0x07,0xE0,0xFC,0x1F,0x83,0xF0,
0x70,
// 11x12 [0x4E 'N']
0xE0,0xFC,0x1F,0xC3,0xFC,0x7F,0xCF,0xDD,0xF9,0xFF,0x1F,0xE1,0xFC,0x1F,0x83,0xF0,
0x70,
// 11x12 [0x4F 'O']
0x1F,0x07,0xF1,0xC7,0x70,0x7E,0x0F,0xC1,0xF8,0x3F,0x07,0xE0,0xEE,0x38,0xFE,0x0F,
0x80,
// 10x12 [0x50 'P']
0xFF,0x9C,0x77,0x1D,0xC7,0x71,0xDF,0xE7,0xF9,0xC0,0x70,0x1C,0x07,0x03,0xE0,
// 11x13 [0x51 'Q']
0x1F,0x0F,0x79,0xC7,0x70,0x7E,0x0F,0xC1,0xF8,0x3F,0x1F,0xE7,0xEF,0xF9,0xFF,0x00,
0xE0,0x7E,
// 10x12 [0x52 'R']
0xFF,0x9C,0x77,0x1D,0xC7,0x71,0xDF,0xE7,0xF9,0xCE,0x71,0xDC,0x77,0x1F,0xC7,
// 10x12 [0x53 'S']
0x7F,0xB8,0x7E,0x1F,0x87,0xE0,0x1F,0xC3,0xF8,0x07,0xE1,0xF8,0x7E,0x1D,0xFE,
// 11x12 [0x54 'T']
0xFF,0xF9,0xCE,0x38,0x87,0x00,0xE0,0x1C,0x03,0x80,0x70,0x0E,0x01,0xC0,0x38,0x1F,
0xC0,
// 9x12 [0x55 'U']
0xE3,0xF1,0xF8,0xFC,0x7E,0x3F,0x1F,0x8F,0xC7,0xE3,0xF1,0xF8,0xEF,0xE0,
// 9x12 [0x56 'V']
0xE3,0xF1,0xF8,0xFC,0x7E,0x3F,0x1F,0x8F,0xC7,0xE3,0xBB,0x8F,0x83,0x80,
// 11x12 [0x57 'W']
0xE0,0xFC,0x1F,0x83,0xF0,0x7E,0x0F,0xC9,0xF9,0x3F,0x27,0x7F,0xCF,0xF8,0xEE,0x1D,
0xC0,
// 9x12 [0x58 'X']
0xE3,0xF1,0xF8,0xEE,0xE3,0xE0,0xE0,0x70,0x7C,0x77,0x71,0xF8,0xFC,0x70,
// 9x12 [0x59 'Y']
0xE3,0xF1,0xF8,0xFC,0x7E,0x3B,0xB8,0xF8,0x38,0x1C,0x0E,0x07,0x0F,0xE0,
// 10x12 [0x5A 'Z']
0xFF,0xF8,0x7C,0x1E,0x0E,0x07,0x03,0x81,0xC0,0xE0,0x70,0x78,0x3E,0x1F,0xFF,
// 7x12 [0x5B '[']
0xFF,0xC3,0x87,0x0E,0x1C,0x38,0x70,0xE1,0xC3,0x87,0xF0,
// 13x12 [0x5C '\']
0x80,0x06,0x00,0x38,0x00,0xE0,0x03,0x80,0x0E,0x00,0x38,0x00,0xE0,0x03,0x80,0x0E,
0x00,0x38,0x00,0x70,
// 7x12 [0x5D ']']
0xFE,0x1C,0x38,0x70,0xE1,0xC3,0x87,0x0E,0x1C,0x3F,0xF0,
// 10x5 [0x5E '^']
0x0C,0x07,0x83,0xF1,0xCE,0xE1,0xC0,
// 15x2 [0x5F '_']
0xFF,0xFF,0xFF,0xFC,
// 5x4 [0x60 '`']
0xE7,0x0E,0x70,
// 10x8 [0x61 'a']
0x7F,0x00,0xE0,0x39,0xFE,0xE3,0xB8,0xEE,0x39,0xFB,
// 10x12 [0x62 'b']
0xF0,0x1C,0x07,0x01,0xC0,0x7F,0x9C,0x77,0x1D,0xC7,0x71,0xDC,0x77,0x1F,0x7E,
// 9x8 [0x63 'c']
0x7F,0x71,0xF8,0xFC,0x0E,0x07,0x1F,0x8E,0xFE,
// 10x12 [0x64 'd']
0x07,0xC0,0xE0,0x38,0x0E,0x7F,0xB8,0xEE,0x3B,0x8E,0xE3,0xB8,0xEE,0x39,0xFB,
// 9x8 [0x65 'e']
0x7F,0x71,0xF8,0xFF,0xFE,0x07,0x1F,0x8E,0xFE,
// 9x12 [0x66 'f']
0x1F,0x1D,0xCE,0xE7,0x03,0x87,0xFB,0xFC,0x70,0x38,0x1C,0x0E,0x1F,0xC0,
// 10x10 [0x67 'g']
0x7E,0xF8,0xEE,0x3B,0x8E,0xE3,0x9F,0xE3,0xF8,0x0E,0xE3,0x9F,0xC0,
// 10x12 [0x68 'h']
0xF0,0x1C,0x07,0x01,0xC0,0x77,0x9E,0x77,0x9D,0xC7,0x71,0xDC,0x77,0x1F,0xC7,
// 9x12 [0x69 'i']
0x1C,0x0E,0x07,0x00,0x0F,0xC0,0xE0,0x70,0x38,0x1C,0x0E,0x07,0x1F,0xF0,
// 9x14 [0x6A 'j']
0x03,0x81,0xC0,0xE0,0x01,0xF8,0x1C,0x0E,0x07,0x03,0x81,0xC0,0xFC,0x76,0x79,0xF8,
// 10x12 [0x6B 'k']
0xF0,0x1C,0x07,0x01,0xC0,0x71,0xDC,0xE7,0x71,0xF8,0x77,0x1C,0xE7,0x1F,0xC7,
// 9x12 [0x6C 'l']
0xFC,0x0E,0x07,0x03,0x81,0xC0,0xE0,0x70,0x38,0x1C,0x0E,0x07,0x1F,0xF0,
// 11x8 [0x6D 'm']
0xFF,0xDC,0x9F,0x93,0xF2,0x7E,0x4F,0xC9,0xF9,0x3F,0x27,
// 9x8 [0x6E 'n']
0xFF,0x71,0xF8,0xFC,0x7E,0x3F,0x1F,0x8F,0xC7,
// 9x8 [0x6F 'o']
0x7F,0x71,0xF8,0xFC,0x7E,0x3F,0x1F,0x8E,0xFE,
// 10x10 [0x70 'p']
0xDF,0x9C,0x77,0x1D,0xC7,0x71,0xDC,0x77,0xF9,0xC0,0x70,0x3E,0x00,
// 10x10 [0x71 'q']
0x7E,0xF8,0xEE,0x3B,0x8E,0xE3,0xB8,0xE7,0xF8,0x0E,0x03,0x81,0xF0,
// 10x8 [0x72 'r']
0xF7,0x9F,0xF7,0x9D,0xC0,0x70,0x1C,0x07,0x03,0xE0,
// 9x8 [0x73 's']
0x7F,0x70,0xF8,0x6F,0x81,0xF6,0x1F,0x0E,0xFE,
// 9x11 [0x74 't']
0x08,0x0C,0x0E,0x1F,0xF3,0x81,0xC0,0xE0,0x70,0x3B,0x9D,0xC7,0xC0,
// 10x8 [0x75 'u']
0xE3,0xB8,0xEE,0x3B,0x8E,0xE3,0xB8,0xEE,0x39,0xFB,
// 9x8 [0x76 'v']
0xE3,0xF1,0xF8,0xFC,0x7E,0x3B,0xB8,0xF8,0x38,
// 11x8 [0x77 'w']
0xE0,0xFC,0x1F,0x83,0xF2,0x7E,0x4E,0xFF,0x8E,0xE1,0xDC,
// 8x8 [0x78 'x']
0xE7,0xE7,0x7E,0x3C,0x3C,0x7E,0xE7,0xE7,
// 10x10 [0x79 'y']
0x71,0xDC,0x77,0x1D,0xC7,0x71,0xCF,0xE1,0xF0,0x1C,0x0E,0x3F,0x00,
// 8x8 [0x7A 'z']
0xFF,0xC7,0x8E,0x1C,0x38,0x71,0xE3,0xFF,
// 10x12 [0x7B '{']
0x0F,0xC7,0x01,0xC0,0x70,0x38,0x38,0x0E,0x00,0xE0,0x1C,0x07,0x01,0xC0,0x3F,
// 3x14 [0x7C '|']
0xFF,0xFF,0xFF,0xFF,0xFF,0xC0,
// 10x12 [0x7D '}']
0xFC,0x03,0x80,0xE0,0x38,0x07,0x00,0x70,0x1C,0x1C,0x0E,0x03,0x80,0xE3,0xF0,
// 12x4 [0x7E '~']
0x7C,0x7E,0xE7,0xE7,0x7E,0x3E,
};
const GFXglyph FreeBigFontGlyphs[] PROGMEM = {
{ 0, 0, 0, 16, 16, -16 }, // 0x20 ' '
{ 0, 5, 13, 16, 4, -14 }, // 0x21 '!'
{ 9, 9, 5, 16, 4, -15 }, // 0x22 '"'
{ 15, 14, 14, 16, 1, -15 }, // 0x23 '#'
{ 40, 10, 14, 16, 3, -15 }, // 0x24 '$'
{ 58, 8, 10, 16, 4, -13 }, // 0x25 '%'
{ 68, 10, 12, 16, 3, -14 }, // 0x26 '&'
{ 83, 4, 4, 16, 4, -14 }, // 0x27 '''
{ 85, 8, 12, 16, 4, -14 }, // 0x28 '('
{ 97, 8, 12, 16, 4, -14 }, // 0x29 ')'
{ 109, 12, 12, 16, 2, -14 }, // 0x2A '*'
{ 127, 8, 8, 16, 4, -12 }, // 0x2B '+'
{ 135, 4, 4, 16, 4, -5 }, // 0x2C ','
{ 137, 10, 2, 16, 3, -9 }, // 0x2D '-'
{ 140, 3, 3, 16, 5, -5 }, // 0x2E '.'
{ 142, 12, 12, 16, 3, -14 }, // 0x2F '/'
{ 160, 10, 12, 16, 3, -14 }, // 0x30 '0'
{ 175, 9, 12, 16, 3, -14 }, // 0x31 '1'
{ 189, 10, 12, 16, 3, -14 }, // 0x32 '2'
{ 204, 10, 12, 16, 3, -14 }, // 0x33 '3'
{ 219, 10, 12, 16, 3, -14 }, // 0x34 '4'
{ 234, 10, 12, 16, 3, -14 }, // 0x35 '5'
{ 249, 10, 12, 16, 3, -14 }, // 0x36 '6'
{ 264, 11, 12, 16, 3, -14 }, // 0x37 '7'
{ 281, 10, 12, 16, 3, -14 }, // 0x38 '8'
{ 296, 10, 12, 16, 3, -14 }, // 0x39 '9'
{ 311, 3, 8, 16, 6, -12 }, // 0x3A ':'
{ 314, 4, 9, 16, 5, -12 }, // 0x3B ';'
{ 319, 9, 14, 16, 3, -15 }, // 0x3C '<'
{ 335, 12, 6, 16, 2, -11 }, // 0x3D '='
{ 344, 9, 14, 16, 3, -15 }, // 0x3E '>'
{ 360, 10, 14, 16, 3, -15 }, // 0x3F '?'
{ 378, 11, 14, 16, 3, -15 }, // 0x40 '@'
{ 398, 10, 12, 16, 3, -14 }, // 0x41 'A'
{ 413, 10, 12, 16, 3, -14 }, // 0x42 'B'
{ 428, 10, 12, 16, 3, -14 }, // 0x43 'C'
{ 443, 10, 12, 16, 3, -14 }, // 0x44 'D'
{ 458, 10, 12, 16, 3, -14 }, // 0x45 'E'
{ 473, 10, 12, 16, 3, -14 }, // 0x46 'F'
{ 488, 10, 12, 16, 3, -14 }, // 0x47 'G'
{ 503, 9, 12, 16, 3, -14 }, // 0x48 'H'
{ 517, 7, 12, 16, 4, -14 }, // 0x49 'I'
{ 528, 12, 12, 16, 2, -14 }, // 0x4A 'J'
{ 546, 10, 12, 16, 3, -14 }, // 0x4B 'K'
{ 561, 10, 12, 16, 3, -14 }, // 0x4C 'L'
{ 576, 11, 12, 16, 3, -14 }, // 0x4D 'M'
{ 593, 11, 12, 16, 3, -14 }, // 0x4E 'N'
{ 610, 11, 12, 16, 3, -14 }, // 0x4F 'O'
{ 627, 10, 12, 16, 3, -14 }, // 0x50 'P'
{ 642, 11, 13, 16, 3, -14 }, // 0x51 'Q'
{ 660, 10, 12, 16, 3, -14 }, // 0x52 'R'
{ 675, 10, 12, 16, 3, -14 }, // 0x53 'S'
{ 690, 11, 12, 16, 3, -14 }, // 0x54 'T'
{ 707, 9, 12, 16, 3, -14 }, // 0x55 'U'
{ 721, 9, 12, 16, 3, -14 }, // 0x56 'V'
{ 735, 11, 12, 16, 3, -14 }, // 0x57 'W'
{ 752, 9, 12, 16, 3, -14 }, // 0x58 'X'
{ 766, 9, 12, 16, 3, -14 }, // 0x59 'Y'
{ 780, 10, 12, 16, 3, -14 }, // 0x5A 'Z'
{ 795, 7, 12, 16, 5, -14 }, // 0x5B '['
{ 806, 13, 12, 16, 3, -14 }, // 0x5C '\'
{ 826, 7, 12, 16, 5, -14 }, // 0x5D ']'
{ 837, 10, 5, 16, 3, -15 }, // 0x5E '^'
{ 844, 15, 2, 16, 1, -2 }, // 0x5F '_'
{ 848, 5, 4, 16, 3, -14 }, // 0x60 '`'
{ 851, 10, 8, 16, 3, -10 }, // 0x61 'a'
{ 861, 10, 12, 16, 3, -14 }, // 0x62 'b'
{ 876, 9, 8, 16, 3, -10 }, // 0x63 'c'
{ 885, 10, 12, 16, 3, -14 }, // 0x64 'd'
{ 900, 9, 8, 16, 3, -10 }, // 0x65 'e'
{ 909, 9, 12, 16, 3, -14 }, // 0x66 'f'
{ 923, 10, 10, 16, 3, -10 }, // 0x67 'g'
{ 936, 10, 12, 16, 3, -14 }, // 0x68 'h'
{ 951, 9, 12, 16, 4, -14 }, // 0x69 'i'
{ 965, 9, 14, 16, 3, -14 }, // 0x6A 'j'
{ 981, 10, 12, 16, 3, -14 }, // 0x6B 'k'
{ 996, 9, 12, 16, 4, -14 }, // 0x6C 'l'
{1010, 11, 8, 16, 3, -10 }, // 0x6D 'm'
{1021, 9, 8, 16, 3, -10 }, // 0x6E 'n'
{1030, 9, 8, 16, 3, -10 }, // 0x6F 'o'
{1039, 10, 10, 16, 3, -10 }, // 0x70 'p'
{1052, 10, 10, 16, 2, -10 }, // 0x71 'q'
{1065, 10, 8, 16, 3, -10 }, // 0x72 'r'
{1075, 9, 8, 16, 3, -10 }, // 0x73 's'
{1084, 9, 11, 16, 3, -13 }, // 0x74 't'
{1097, 10, 8, 16, 3, -10 }, // 0x75 'u'
{1107, 9, 8, 16, 3, -10 }, // 0x76 'v'
{1116, 11, 8, 16, 3, -10 }, // 0x77 'w'
{1127, 8, 8, 16, 3, -10 }, // 0x78 'x'
{1135, 10, 10, 16, 3, -10 }, // 0x79 'y'
{1148, 8, 8, 16, 3, -10 }, // 0x7A 'z'
{1156, 10, 12, 16, 3, -14 }, // 0x7B '{'
{1171, 3, 14, 16, 7, -15 }, // 0x7C '|'
{1177, 10, 12, 16, 3, -14 }, // 0x7D '}'
{1192, 12, 4, 16, 2, -14 }, // 0x7E '~'
};
const GFXfont FreeBigFont PROGMEM = {
(uint8_t *)FreeBigFontBitmaps,
(GFXglyph *)FreeBigFontGlyphs,
32, 126, 16
};
// FreeBigFont bitmap size = 1198 [1863] [3139]
const uint8_t FreeSevenSegNumFontBitmaps[] PROGMEM = {
// 27x46 [0x30 '0']
0x03,0xFF,0xF8,0x00,0xFF,0xFF,0x80,0x3F,0xFF,0xF8,0x03,0xFF,0xFE,0xC3,0x3F,0xFF,
0xBC,0xF0,0x00,0x0F,0xFF,0x00,0x01,0xFF,0xE0,0x00,0x3F,0xFC,0x00,0x07,0xFF,0x80,
0x00,0xFF,0xF0,0x00,0x1F,0xFE,0x00,0x03,0xFF,0xC0,0x00,0x7F,0xF8,0x00,0x0F,0xFF,
0x00,0x01,0xFF,0xE0,0x00,0x3F,0xFC,0x00,0x07,0xFF,0x80,0x00,0xFF,0xF0,0x00,0x1F,
0xFC,0x00,0x00,0xFE,0x00,0x00,0x07,0x00,0x00,0x00,0x40,0x00,0x00,0x04,0x00,0x00,
0x00,0xE0,0x00,0x00,0x7F,0x00,0x00,0x3F,0xF0,0x00,0x1F,0xFE,0x00,0x03,0xFF,0xC0,
0x00,0x7F,0xF8,0x00,0x0F,0xFF,0x00,0x01,0xFF,0xE0,0x00,0x3F,0xFC,0x00,0x07,0xFF,
0x80,0x00,0xFF,0xF0,0x00,0x1F,0xFE,0x00,0x03,0xFF,0xC0,0x00,0x7F,0xF8,0x00,0x0F,
0xFF,0x00,0x01,0xFF,0xE0,0x00,0x3F,0x78,0x00,0x03,0xC6,0x7F,0xFF,0x30,0x1F,0xFF,
0xF0,0x07,0xFF,0xFF,0x00,0x7F,0xFF,0xC0,0x07,0xFF,0xF0,0x00,
// 6x39 [0x31 '1']
0x31,0xEF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0x3C,0x30,0x40,0x00,
0x33,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFD,0xE3,0x00,
// 27x46 [0x32 '2']
0x03,0xFF,0xF8,0x00,0xFF,0xFF,0x80,0x3F,0xFF,0xF8,0x03,0xFF,0xFE,0xC0,0x3F,0xFF,
0xBC,0x00,0x00,0x0F,0xC0,0x00,0x01,0xF8,0x00,0x00,0x3F,0x00,0x00,0x07,0xE0,0x00,
0x00,0xFC,0x00,0x00,0x1F,0x80,0x00,0x03,0xF0,0x00,0x00,0x7E,0x00,0x00,0x0F,0xC0,
0x00,0x01,0xF8,0x00,0x00,0x3F,0x00,0x00,0x07,0xE0,0x00,0x00,0xFC,0x00,0x00,0x1F,
0x80,0x00,0x00,0xF0,0x7F,0xFF,0x86,0x1F,0xFF,0xFC,0x4F,0xFF,0xFF,0xE4,0xFF,0xFF,
0xF8,0xE7,0xFF,0xFC,0x1F,0x00,0x00,0x03,0xF0,0x00,0x00,0x7E,0x00,0x00,0x0F,0xC0,
0x00,0x01,0xF8,0x00,0x00,0x3F,0x00,0x00,0x07,0xE0,0x00,0x00,0xFC,0x00,0x00,0x1F,
0x80,0x00,0x03,0xF0,0x00,0x00,0x7E,0x00,0x00,0x0F,0xC0,0x00,0x01,0xF8,0x00,0x00,
0x3F,0x00,0x00,0x07,0xE0,0x00,0x00,0x78,0x00,0x00,0x06,0x7F,0xFF,0x00,0x1F,0xFF,
0xF0,0x07,0xFF,0xFF,0x00,0x7F,0xFF,0xC0,0x07,0xFF,0xF0,0x00,
// 25x46 [0x33 '3']
0x0F,0xFF,0xE0,0x0F,0xFF,0xF8,0x0F,0xFF,0xFE,0x03,0xFF,0xFE,0xC0,0xFF,0xFE,0xF0,
0x00,0x00,0xFC,0x00,0x00,0x7E,0x00,0x00,0x3F,0x00,0x00,0x1F,0x80,0x00,0x0F,0xC0,
0x00,0x07,0xE0,0x00,0x03,0xF0,0x00,0x01,0xF8,0x00,0x00,0xFC,0x00,0x00,0x7E,0x00,
0x00,0x3F,0x00,0x00,0x1F,0x80,0x00,0x0F,0xC0,0x00,0x07,0xE0,0x00,0x00,0xF1,0xFF,
0xFE,0x19,0xFF,0xFF,0xC7,0xFF,0xFF,0xF8,0xFF,0xFF,0xF8,0x1F,0xFF,0xF1,0x80,0x00,
0x03,0xC0,0x00,0x07,0xE0,0x00,0x03,0xF0,0x00,0x01,0xF8,0x00,0x00,0xFC,0x00,0x00,
0x7E,0x00,0x00,0x3F,0x00,0x00,0x1F,0x80,0x00,0x0F,0xC0,0x00,0x07,0xE0,0x00,0x03,
0xF0,0x00,0x01,0xF8,0x00,0x00,0xFC,0x00,0x00,0x7E,0x00,0x00,0x3F,0x00,0x00,0x0F,
0x07,0xFF,0xF3,0x07,0xFF,0xFC,0x07,0xFF,0xFF,0x01,0xFF,0xFF,0x00,0x7F,0xFF,0x00,
// 27x39 [0x34 '4']
0x00,0x00,0x01,0x86,0x00,0x00,0x79,0xE0,0x00,0x1F,0xFE,0x00,0x03,0xFF,0xC0,0x00,
0x7F,0xF8,0x00,0x0F,0xFF,0x00,0x01,0xFF,0xE0,0x00,0x3F,0xFC,0x00,0x07,0xFF,0x80,
0x00,0xFF,0xF0,0x00,0x1F,0xFE,0x00,0x03,0xFF,0xC0,0x00,0x7F,0xF8,0x00,0x0F,0xFF,
0x00,0x01,0xFF,0xE0,0x00,0x3F,0xF8,0x00,0x01,0xFC,0xFF,0xFF,0x0E,0x3F,0xFF,0xF8,
0x9F,0xFF,0xFF,0xC1,0xFF,0xFF,0xF0,0x0F,0xFF,0xF8,0xC0,0x00,0x00,0x78,0x00,0x00,
0x3F,0x00,0x00,0x07,0xE0,0x00,0x00,0xFC,0x00,0x00,0x1F,0x80,0x00,0x03,0xF0,0x00,
0x00,0x7E,0x00,0x00,0x0F,0xC0,0x00,0x01,0xF8,0x00,0x00,0x3F,0x00,0x00,0x07,0xE0,
0x00,0x00,0xFC,0x00,0x00,0x1F,0x80,0x00,0x03,0xF0,0x00,0x00,0x7E,0x00,0x00,0x07,
0x80,0x00,0x00,0x60,
// 27x46 [0x35 '5']
0x03,0xFF,0xF8,0x00,0xFF,0xFF,0x80,0x3F,0xFF,0xF8,0x03,0xFF,0xFE,0x03,0x3F,0xFF,
0x80,0xF0,0x00,0x00,0x3F,0x00,0x00,0x07,0xE0,0x00,0x00,0xFC,0x00,0x00,0x1F,0x80,
0x00,0x03,0xF0,0x00,0x00,0x7E,0x00,0x00,0x0F,0xC0,0x00,0x01,0xF8,0x00,0x00,0x3F,
0x00,0x00,0x07,0xE0,0x00,0x00,0xFC,0x00,0x00,0x1F,0x80,0x00,0x03,0xF0,0x00,0x00,
0x7C,0x00,0x00,0x0E,0x7F,0xFF,0x81,0x1F,0xFF,0xFC,0x0F,0xFF,0xFF,0xE0,0xFF,0xFF,
0xF8,0x07,0xFF,0xFC,0x60,0x00,0x00,0x3C,0x00,0x00,0x1F,0x80,0x00,0x03,0xF0,0x00,
0x00,0x7E,0x00,0x00,0x0F,0xC0,0x00,0x01,0xF8,0x00,0x00,0x3F,0x00,0x00,0x07,0xE0,
0x00,0x00,0xFC,0x00,0x00,0x1F,0x80,0x00,0x03,0xF0,0x00,0x00,0x7E,0x00,0x00,0x0F,
0xC0,0x00,0x01,0xF8,0x00,0x00,0x3F,0x00,0x00,0x03,0xC0,0x7F,0xFF,0x30,0x1F,0xFF,
0xF0,0x07,0xFF,0xFF,0x00,0x7F,0xFF,0xC0,0x07,0xFF,0xF0,0x00,
// 27x46 [0x36 '6']
0x03,0xFF,0xF8,0x00,0xFF,0xFF,0x80,0x3F,0xFF,0xF8,0x03,0xFF,0xFE,0x03,0x3F,0xFF,
0x80,0xF0,0x00,0x00,0x3F,0x00,0x00,0x07,0xE0,0x00,0x00,0xFC,0x00,0x00,0x1F,0x80,
0x00,0x03,0xF0,0x00,0x00,0x7E,0x00,0x00,0x0F,0xC0,0x00,0x01,0xF8,0x00,0x00,0x3F,
0x00,0x00,0x07,0xE0,0x00,0x00,0xFC,0x00,0x00,0x1F,0x80,0x00,0x03,0xF0,0x00,0x00,
0x7C,0x00,0x00,0x0E,0x7F,0xFF,0x81,0x1F,0xFF,0xFC,0x0F,0xFF,0xFF,0xE4,0xFF,0xFF,
0xF8,0xE7,0xFF,0xFC,0x7F,0x00,0x00,0x3F,0xF0,0x00,0x1F,0xFE,0x00,0x03,0xFF,0xC0,
0x00,0x7F,0xF8,0x00,0x0F,0xFF,0x00,0x01,0xFF,0xE0,0x00,0x3F,0xFC,0x00,0x07,0xFF,
0x80,0x00,0xFF,0xF0,0x00,0x1F,0xFE,0x00,0x03,0xFF,0xC0,0x00,0x7F,0xF8,0x00,0x0F,
0xFF,0x00,0x01,0xFF,0xE0,0x00,0x3F,0x78,0x00,0x03,0xC6,0x7F,0xFF,0x30,0x1F,0xFF,
0xF0,0x07,0xFF,0xFF,0x00,0x7F,0xFF,0xC0,0x07,0xFF,0xF0,0x00,
// 23x42 [0x37 '7']
0x3F,0xFF,0x80,0xFF,0xFF,0x83,0xFF,0xFF,0x83,0xFF,0xFE,0xC3,0xFF,0xFB,0xC0,0x00,
0x0F,0xC0,0x00,0x1F,0x80,0x00,0x3F,0x00,0x00,0x7E,0x00,0x00,0xFC,0x00,0x01,0xF8,
0x00,0x03,0xF0,0x00,0x07,0xE0,0x00,0x0F,0xC0,0x00,0x1F,0x80,0x00,0x3F,0x00,0x00,
0x7E,0x00,0x00,0xFC,0x00,0x01,0xF8,0x00,0x00,0xF0,0x00,0x00,0x60,0x00,0x00,0x40,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x06,0x00,0x00,0x3C,0x00,0x01,0xF8,0x00,0x03,
0xF0,0x00,0x07,0xE0,0x00,0x0F,0xC0,0x00,0x1F,0x80,0x00,0x3F,0x00,0x00,0x7E,0x00,
0x00,0xFC,0x00,0x01,0xF8,0x00,0x03,0xF0,0x00,0x07,0xE0,0x00,0x0F,0xC0,0x00,0x1F,
0x80,0x00,0x3F,0x00,0x00,0x3C,0x00,0x00,0x30,
// 27x46 [0x38 '8']
0x03,0xFF,0xF8,0x00,0xFF,0xFF,0x80,0x3F,0xFF,0xF8,0x03,0xFF,0xFE,0xC3,0x3F,0xFF,
0xBC,0xF0,0x00,0x0F,0xFF,0x00,0x01,0xFF,0xE0,0x00,0x3F,0xFC,0x00,0x07,0xFF,0x80,
0x00,0xFF,0xF0,0x00,0x1F,0xFE,0x00,0x03,0xFF,0xC0,0x00,0x7F,0xF8,0x00,0x0F,0xFF,
0x00,0x01,0xFF,0xE0,0x00,0x3F,0xFC,0x00,0x07,0xFF,0x80,0x00,0xFF,0xF0,0x00,0x1F,
0xFC,0x00,0x00,0xFE,0x7F,0xFF,0x87,0x1F,0xFF,0xFC,0x4F,0xFF,0xFF,0xE4,0xFF,0xFF,
0xF8,0xE7,0xFF,0xFC,0x7F,0x00,0x00,0x3F,0xF0,0x00,0x1F,0xFE,0x00,0x03,0xFF,0xC0,
0x00,0x7F,0xF8,0x00,0x0F,0xFF,0x00,0x01,0xFF,0xE0,0x00,0x3F,0xFC,0x00,0x07,0xFF,
0x80,0x00,0xFF,0xF0,0x00,0x1F,0xFE,0x00,0x03,0xFF,0xC0,0x00,0x7F,0xF8,0x00,0x0F,
0xFF,0x00,0x01,0xFF,0xE0,0x00,0x3F,0x78,0x00,0x03,0xC6,0x7F,0xFF,0x30,0x1F,0xFF,
0xF0,0x07,0xFF,0xFF,0x00,0x7F,0xFF,0xC0,0x07,0xFF,0xF0,0x00,
// 27x46 [0x39 '9']
0x03,0xFF,0xF8,0x00,0xFF,0xFF,0x80,0x3F,0xFF,0xF8,0x03,0xFF,0xFE,0xC3,0x3F,0xFF,
0xBC,0xF0,0x00,0x0F,0xFF,0x00,0x01,0xFF,0xE0,0x00,0x3F,0xFC,0x00,0x07,0xFF,0x80,
0x00,0xFF,0xF0,0x00,0x1F,0xFE,0x00,0x03,0xFF,0xC0,0x00,0x7F,0xF8,0x00,0x0F,0xFF,
0x00,0x01,0xFF,0xE0,0x00,0x3F,0xFC,0x00,0x07,0xFF,0x80,0x00,0xFF,0xF0,0x00,0x1F,
0xFC,0x00,0x00,0xFE,0x7F,0xFF,0x87,0x1F,0xFF,0xFC,0x4F,0xFF,0xFF,0xE0,0xFF,0xFF,
0xF8,0x07,0xFF,0xFC,0x60,0x00,0x00,0x3C,0x00,0x00,0x1F,0x80,0x00,0x03,0xF0,0x00,
0x00,0x7E,0x00,0x00,0x0F,0xC0,0x00,0x01,0xF8,0x00,0x00,0x3F,0x00,0x00,0x07,0xE0,
0x00,0x00,0xFC,0x00,0x00,0x1F,0x80,0x00,0x03,0xF0,0x00,0x00,0x7E,0x00,0x00,0x0F,
0xC0,0x00,0x01,0xF8,0x00,0x00,0x3F,0x00,0x00,0x03,0xC0,0x7F,0xFF,0x30,0x1F,0xFF,
0xF0,0x07,0xFF,0xFF,0x00,0x7F,0xFF,0xC0,0x07,0xFF,0xF0,0x00,
};
const GFXglyph FreeSevenSegNumFontGlyphs[] PROGMEM = {
{ 0, 27, 46, 32, 2, -48 }, // 0x30 '0'
{ 156, 6, 39, 32, 23, -45 }, // 0x31 '1'
{ 186, 27, 46, 32, 2, -48 }, // 0x32 '2'
{ 342, 25, 46, 32, 4, -48 }, // 0x33 '3'
{ 486, 27, 39, 32, 2, -45 }, // 0x34 '4'
{ 618, 27, 46, 32, 2, -48 }, // 0x35 '5'
{ 774, 27, 46, 32, 2, -48 }, // 0x36 '6'
{ 930, 23, 42, 32, 6, -48 }, // 0x37 '7'
{1051, 27, 46, 32, 2, -48 }, // 0x38 '8'
{1207, 27, 46, 32, 2, -48 }, // 0x39 '9'
};
const GFXfont FreeSevenSegNumFont PROGMEM = {
(uint8_t *)FreeSevenSegNumFontBitmaps,
(GFXglyph *)FreeSevenSegNumFontGlyphs,
48, 57, 50
};
// FreeSevenSegNumFont bitmap size = 1363 [1433] [2014]
libraries/MCUFRIEND_kbv/FreeSevenSegNumFontPlusPlus.h
+131
View File
@@ -0,0 +1,131 @@
// generate FreeFont from UTFT font
const uint8_t FreeSevenSegNumFontPlusPlusBitmaps[] PROGMEM = {
// 7x7 [0x2E '.']
0x38, 0xFB, 0xFF, 0xFF, 0xEF, 0x8E, 0x00,
// 0x0 [0x2F '/']
// 27x46 [0x30 '0']
0x03, 0xFF, 0xF8, 0x00, 0xFF, 0xFF, 0x80, 0x3F, 0xFF, 0xF8, 0x03, 0xFF, 0xFE, 0xC3, 0x3F, 0xFF,
0xBC, 0xF0, 0x00, 0x0F, 0xFF, 0x00, 0x01, 0xFF, 0xE0, 0x00, 0x3F, 0xFC, 0x00, 0x07, 0xFF, 0x80,
0x00, 0xFF, 0xF0, 0x00, 0x1F, 0xFE, 0x00, 0x03, 0xFF, 0xC0, 0x00, 0x7F, 0xF8, 0x00, 0x0F, 0xFF,
0x00, 0x01, 0xFF, 0xE0, 0x00, 0x3F, 0xFC, 0x00, 0x07, 0xFF, 0x80, 0x00, 0xFF, 0xF0, 0x00, 0x1F,
0xFC, 0x00, 0x00, 0xFE, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x04, 0x00, 0x00,
0x00, 0xE0, 0x00, 0x00, 0x7F, 0x00, 0x00, 0x3F, 0xF0, 0x00, 0x1F, 0xFE, 0x00, 0x03, 0xFF, 0xC0,
0x00, 0x7F, 0xF8, 0x00, 0x0F, 0xFF, 0x00, 0x01, 0xFF, 0xE0, 0x00, 0x3F, 0xFC, 0x00, 0x07, 0xFF,
0x80, 0x00, 0xFF, 0xF0, 0x00, 0x1F, 0xFE, 0x00, 0x03, 0xFF, 0xC0, 0x00, 0x7F, 0xF8, 0x00, 0x0F,
0xFF, 0x00, 0x01, 0xFF, 0xE0, 0x00, 0x3F, 0x78, 0x00, 0x03, 0xC6, 0x7F, 0xFF, 0x30, 0x1F, 0xFF,
0xF0, 0x07, 0xFF, 0xFF, 0x00, 0x7F, 0xFF, 0xC0, 0x07, 0xFF, 0xF0, 0x00,
// 6x39 [0x31 '1']
0x31, 0xEF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x3C, 0x30, 0x40, 0x00,
0x33, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFD, 0xE3, 0x00,
// 27x46 [0x32 '2']
0x03, 0xFF, 0xF8, 0x00, 0xFF, 0xFF, 0x80, 0x3F, 0xFF, 0xF8, 0x03, 0xFF, 0xFE, 0xC0, 0x3F, 0xFF,
0xBC, 0x00, 0x00, 0x0F, 0xC0, 0x00, 0x01, 0xF8, 0x00, 0x00, 0x3F, 0x00, 0x00, 0x07, 0xE0, 0x00,
0x00, 0xFC, 0x00, 0x00, 0x1F, 0x80, 0x00, 0x03, 0xF0, 0x00, 0x00, 0x7E, 0x00, 0x00, 0x0F, 0xC0,
0x00, 0x01, 0xF8, 0x00, 0x00, 0x3F, 0x00, 0x00, 0x07, 0xE0, 0x00, 0x00, 0xFC, 0x00, 0x00, 0x1F,
0x80, 0x00, 0x00, 0xF0, 0x7F, 0xFF, 0x86, 0x1F, 0xFF, 0xFC, 0x4F, 0xFF, 0xFF, 0xE4, 0xFF, 0xFF,
0xF8, 0xE7, 0xFF, 0xFC, 0x1F, 0x00, 0x00, 0x03, 0xF0, 0x00, 0x00, 0x7E, 0x00, 0x00, 0x0F, 0xC0,
0x00, 0x01, 0xF8, 0x00, 0x00, 0x3F, 0x00, 0x00, 0x07, 0xE0, 0x00, 0x00, 0xFC, 0x00, 0x00, 0x1F,
0x80, 0x00, 0x03, 0xF0, 0x00, 0x00, 0x7E, 0x00, 0x00, 0x0F, 0xC0, 0x00, 0x01, 0xF8, 0x00, 0x00,
0x3F, 0x00, 0x00, 0x07, 0xE0, 0x00, 0x00, 0x78, 0x00, 0x00, 0x06, 0x7F, 0xFF, 0x00, 0x1F, 0xFF,
0xF0, 0x07, 0xFF, 0xFF, 0x00, 0x7F, 0xFF, 0xC0, 0x07, 0xFF, 0xF0, 0x00,
// 25x46 [0x33 '3']
0x0F, 0xFF, 0xE0, 0x0F, 0xFF, 0xF8, 0x0F, 0xFF, 0xFE, 0x03, 0xFF, 0xFE, 0xC0, 0xFF, 0xFE, 0xF0,
0x00, 0x00, 0xFC, 0x00, 0x00, 0x7E, 0x00, 0x00, 0x3F, 0x00, 0x00, 0x1F, 0x80, 0x00, 0x0F, 0xC0,
0x00, 0x07, 0xE0, 0x00, 0x03, 0xF0, 0x00, 0x01, 0xF8, 0x00, 0x00, 0xFC, 0x00, 0x00, 0x7E, 0x00,
0x00, 0x3F, 0x00, 0x00, 0x1F, 0x80, 0x00, 0x0F, 0xC0, 0x00, 0x07, 0xE0, 0x00, 0x00, 0xF1, 0xFF,
0xFE, 0x19, 0xFF, 0xFF, 0xC7, 0xFF, 0xFF, 0xF8, 0xFF, 0xFF, 0xF8, 0x1F, 0xFF, 0xF1, 0x80, 0x00,
0x03, 0xC0, 0x00, 0x07, 0xE0, 0x00, 0x03, 0xF0, 0x00, 0x01, 0xF8, 0x00, 0x00, 0xFC, 0x00, 0x00,
0x7E, 0x00, 0x00, 0x3F, 0x00, 0x00, 0x1F, 0x80, 0x00, 0x0F, 0xC0, 0x00, 0x07, 0xE0, 0x00, 0x03,
0xF0, 0x00, 0x01, 0xF8, 0x00, 0x00, 0xFC, 0x00, 0x00, 0x7E, 0x00, 0x00, 0x3F, 0x00, 0x00, 0x0F,
0x07, 0xFF, 0xF3, 0x07, 0xFF, 0xFC, 0x07, 0xFF, 0xFF, 0x01, 0xFF, 0xFF, 0x00, 0x7F, 0xFF, 0x00,
// 27x39 [0x34 '4']
0x00, 0x00, 0x01, 0x86, 0x00, 0x00, 0x79, 0xE0, 0x00, 0x1F, 0xFE, 0x00, 0x03, 0xFF, 0xC0, 0x00,
0x7F, 0xF8, 0x00, 0x0F, 0xFF, 0x00, 0x01, 0xFF, 0xE0, 0x00, 0x3F, 0xFC, 0x00, 0x07, 0xFF, 0x80,
0x00, 0xFF, 0xF0, 0x00, 0x1F, 0xFE, 0x00, 0x03, 0xFF, 0xC0, 0x00, 0x7F, 0xF8, 0x00, 0x0F, 0xFF,
0x00, 0x01, 0xFF, 0xE0, 0x00, 0x3F, 0xF8, 0x00, 0x01, 0xFC, 0xFF, 0xFF, 0x0E, 0x3F, 0xFF, 0xF8,
0x9F, 0xFF, 0xFF, 0xC1, 0xFF, 0xFF, 0xF0, 0x0F, 0xFF, 0xF8, 0xC0, 0x00, 0x00, 0x78, 0x00, 0x00,
0x3F, 0x00, 0x00, 0x07, 0xE0, 0x00, 0x00, 0xFC, 0x00, 0x00, 0x1F, 0x80, 0x00, 0x03, 0xF0, 0x00,
0x00, 0x7E, 0x00, 0x00, 0x0F, 0xC0, 0x00, 0x01, 0xF8, 0x00, 0x00, 0x3F, 0x00, 0x00, 0x07, 0xE0,
0x00, 0x00, 0xFC, 0x00, 0x00, 0x1F, 0x80, 0x00, 0x03, 0xF0, 0x00, 0x00, 0x7E, 0x00, 0x00, 0x07,
0x80, 0x00, 0x00, 0x60,
// 27x46 [0x35 '5']
0x03, 0xFF, 0xF8, 0x00, 0xFF, 0xFF, 0x80, 0x3F, 0xFF, 0xF8, 0x03, 0xFF, 0xFE, 0x03, 0x3F, 0xFF,
0x80, 0xF0, 0x00, 0x00, 0x3F, 0x00, 0x00, 0x07, 0xE0, 0x00, 0x00, 0xFC, 0x00, 0x00, 0x1F, 0x80,
0x00, 0x03, 0xF0, 0x00, 0x00, 0x7E, 0x00, 0x00, 0x0F, 0xC0, 0x00, 0x01, 0xF8, 0x00, 0x00, 0x3F,
0x00, 0x00, 0x07, 0xE0, 0x00, 0x00, 0xFC, 0x00, 0x00, 0x1F, 0x80, 0x00, 0x03, 0xF0, 0x00, 0x00,
0x7C, 0x00, 0x00, 0x0E, 0x7F, 0xFF, 0x81, 0x1F, 0xFF, 0xFC, 0x0F, 0xFF, 0xFF, 0xE0, 0xFF, 0xFF,
0xF8, 0x07, 0xFF, 0xFC, 0x60, 0x00, 0x00, 0x3C, 0x00, 0x00, 0x1F, 0x80, 0x00, 0x03, 0xF0, 0x00,
0x00, 0x7E, 0x00, 0x00, 0x0F, 0xC0, 0x00, 0x01, 0xF8, 0x00, 0x00, 0x3F, 0x00, 0x00, 0x07, 0xE0,
0x00, 0x00, 0xFC, 0x00, 0x00, 0x1F, 0x80, 0x00, 0x03, 0xF0, 0x00, 0x00, 0x7E, 0x00, 0x00, 0x0F,
0xC0, 0x00, 0x01, 0xF8, 0x00, 0x00, 0x3F, 0x00, 0x00, 0x03, 0xC0, 0x7F, 0xFF, 0x30, 0x1F, 0xFF,
0xF0, 0x07, 0xFF, 0xFF, 0x00, 0x7F, 0xFF, 0xC0, 0x07, 0xFF, 0xF0, 0x00,
// 27x46 [0x36 '6']
0x03, 0xFF, 0xF8, 0x00, 0xFF, 0xFF, 0x80, 0x3F, 0xFF, 0xF8, 0x03, 0xFF, 0xFE, 0x03, 0x3F, 0xFF,
0x80, 0xF0, 0x00, 0x00, 0x3F, 0x00, 0x00, 0x07, 0xE0, 0x00, 0x00, 0xFC, 0x00, 0x00, 0x1F, 0x80,
0x00, 0x03, 0xF0, 0x00, 0x00, 0x7E, 0x00, 0x00, 0x0F, 0xC0, 0x00, 0x01, 0xF8, 0x00, 0x00, 0x3F,
0x00, 0x00, 0x07, 0xE0, 0x00, 0x00, 0xFC, 0x00, 0x00, 0x1F, 0x80, 0x00, 0x03, 0xF0, 0x00, 0x00,
0x7C, 0x00, 0x00, 0x0E, 0x7F, 0xFF, 0x81, 0x1F, 0xFF, 0xFC, 0x0F, 0xFF, 0xFF, 0xE4, 0xFF, 0xFF,
0xF8, 0xE7, 0xFF, 0xFC, 0x7F, 0x00, 0x00, 0x3F, 0xF0, 0x00, 0x1F, 0xFE, 0x00, 0x03, 0xFF, 0xC0,
0x00, 0x7F, 0xF8, 0x00, 0x0F, 0xFF, 0x00, 0x01, 0xFF, 0xE0, 0x00, 0x3F, 0xFC, 0x00, 0x07, 0xFF,
0x80, 0x00, 0xFF, 0xF0, 0x00, 0x1F, 0xFE, 0x00, 0x03, 0xFF, 0xC0, 0x00, 0x7F, 0xF8, 0x00, 0x0F,
0xFF, 0x00, 0x01, 0xFF, 0xE0, 0x00, 0x3F, 0x78, 0x00, 0x03, 0xC6, 0x7F, 0xFF, 0x30, 0x1F, 0xFF,
0xF0, 0x07, 0xFF, 0xFF, 0x00, 0x7F, 0xFF, 0xC0, 0x07, 0xFF, 0xF0, 0x00,
// 23x42 [0x37 '7']
0x3F, 0xFF, 0x80, 0xFF, 0xFF, 0x83, 0xFF, 0xFF, 0x83, 0xFF, 0xFE, 0xC3, 0xFF, 0xFB, 0xC0, 0x00,
0x0F, 0xC0, 0x00, 0x1F, 0x80, 0x00, 0x3F, 0x00, 0x00, 0x7E, 0x00, 0x00, 0xFC, 0x00, 0x01, 0xF8,
0x00, 0x03, 0xF0, 0x00, 0x07, 0xE0, 0x00, 0x0F, 0xC0, 0x00, 0x1F, 0x80, 0x00, 0x3F, 0x00, 0x00,
0x7E, 0x00, 0x00, 0xFC, 0x00, 0x01, 0xF8, 0x00, 0x00, 0xF0, 0x00, 0x00, 0x60, 0x00, 0x00, 0x40,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x3C, 0x00, 0x01, 0xF8, 0x00, 0x03,
0xF0, 0x00, 0x07, 0xE0, 0x00, 0x0F, 0xC0, 0x00, 0x1F, 0x80, 0x00, 0x3F, 0x00, 0x00, 0x7E, 0x00,
0x00, 0xFC, 0x00, 0x01, 0xF8, 0x00, 0x03, 0xF0, 0x00, 0x07, 0xE0, 0x00, 0x0F, 0xC0, 0x00, 0x1F,
0x80, 0x00, 0x3F, 0x00, 0x00, 0x3C, 0x00, 0x00, 0x30,
// 27x46 [0x38 '8']
0x03, 0xFF, 0xF8, 0x00, 0xFF, 0xFF, 0x80, 0x3F, 0xFF, 0xF8, 0x03, 0xFF, 0xFE, 0xC3, 0x3F, 0xFF,
0xBC, 0xF0, 0x00, 0x0F, 0xFF, 0x00, 0x01, 0xFF, 0xE0, 0x00, 0x3F, 0xFC, 0x00, 0x07, 0xFF, 0x80,
0x00, 0xFF, 0xF0, 0x00, 0x1F, 0xFE, 0x00, 0x03, 0xFF, 0xC0, 0x00, 0x7F, 0xF8, 0x00, 0x0F, 0xFF,
0x00, 0x01, 0xFF, 0xE0, 0x00, 0x3F, 0xFC, 0x00, 0x07, 0xFF, 0x80, 0x00, 0xFF, 0xF0, 0x00, 0x1F,
0xFC, 0x00, 0x00, 0xFE, 0x7F, 0xFF, 0x87, 0x1F, 0xFF, 0xFC, 0x4F, 0xFF, 0xFF, 0xE4, 0xFF, 0xFF,
0xF8, 0xE7, 0xFF, 0xFC, 0x7F, 0x00, 0x00, 0x3F, 0xF0, 0x00, 0x1F, 0xFE, 0x00, 0x03, 0xFF, 0xC0,
0x00, 0x7F, 0xF8, 0x00, 0x0F, 0xFF, 0x00, 0x01, 0xFF, 0xE0, 0x00, 0x3F, 0xFC, 0x00, 0x07, 0xFF,
0x80, 0x00, 0xFF, 0xF0, 0x00, 0x1F, 0xFE, 0x00, 0x03, 0xFF, 0xC0, 0x00, 0x7F, 0xF8, 0x00, 0x0F,
0xFF, 0x00, 0x01, 0xFF, 0xE0, 0x00, 0x3F, 0x78, 0x00, 0x03, 0xC6, 0x7F, 0xFF, 0x30, 0x1F, 0xFF,
0xF0, 0x07, 0xFF, 0xFF, 0x00, 0x7F, 0xFF, 0xC0, 0x07, 0xFF, 0xF0, 0x00,
// 27x46 [0x39 '9']
0x03, 0xFF, 0xF8, 0x00, 0xFF, 0xFF, 0x80, 0x3F, 0xFF, 0xF8, 0x03, 0xFF, 0xFE, 0xC3, 0x3F, 0xFF,
0xBC, 0xF0, 0x00, 0x0F, 0xFF, 0x00, 0x01, 0xFF, 0xE0, 0x00, 0x3F, 0xFC, 0x00, 0x07, 0xFF, 0x80,
0x00, 0xFF, 0xF0, 0x00, 0x1F, 0xFE, 0x00, 0x03, 0xFF, 0xC0, 0x00, 0x7F, 0xF8, 0x00, 0x0F, 0xFF,
0x00, 0x01, 0xFF, 0xE0, 0x00, 0x3F, 0xFC, 0x00, 0x07, 0xFF, 0x80, 0x00, 0xFF, 0xF0, 0x00, 0x1F,
0xFC, 0x00, 0x00, 0xFE, 0x7F, 0xFF, 0x87, 0x1F, 0xFF, 0xFC, 0x4F, 0xFF, 0xFF, 0xE0, 0xFF, 0xFF,
0xF8, 0x07, 0xFF, 0xFC, 0x60, 0x00, 0x00, 0x3C, 0x00, 0x00, 0x1F, 0x80, 0x00, 0x03, 0xF0, 0x00,
0x00, 0x7E, 0x00, 0x00, 0x0F, 0xC0, 0x00, 0x01, 0xF8, 0x00, 0x00, 0x3F, 0x00, 0x00, 0x07, 0xE0,
0x00, 0x00, 0xFC, 0x00, 0x00, 0x1F, 0x80, 0x00, 0x03, 0xF0, 0x00, 0x00, 0x7E, 0x00, 0x00, 0x0F,
0xC0, 0x00, 0x01, 0xF8, 0x00, 0x00, 0x3F, 0x00, 0x00, 0x03, 0xC0, 0x7F, 0xFF, 0x30, 0x1F, 0xFF,
0xF0, 0x07, 0xFF, 0xFF, 0x00, 0x7F, 0xFF, 0xC0, 0x07, 0xFF, 0xF0, 0x00,
// 7x28 [0x3A ':']
0x38, 0xFB, 0xFF, 0xFF, 0xEF, 0x8E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x07, 0x1F, 0x7F, 0xFF, 0xFD, 0xF1, 0xC0,
};
// strip blank pixels: top = 0, bot = 2, left = 2, rt = 0, adv = 32, desc = 0
const GFXglyph FreeSevenSegNumFontPlusPlusGlyphs[] PROGMEM = {
{ 0, 7, 7, 32, 14, -12 }, // 0x2E '.'
{ 7, 0, 0, 32, 32, -50 }, // 0x2F '/'
{ 7, 27, 46, 32, 2, -48 }, // 0x30 '0'
{ 163, 6, 39, 32, 23, -45 }, // 0x31 '1'
{ 193, 27, 46, 32, 2, -48 }, // 0x32 '2'
{ 349, 25, 46, 32, 4, -48 }, // 0x33 '3'
{ 493, 27, 39, 32, 2, -45 }, // 0x34 '4'
{ 625, 27, 46, 32, 2, -48 }, // 0x35 '5'
{ 781, 27, 46, 32, 2, -48 }, // 0x36 '6'
{ 937, 23, 42, 32, 6, -48 }, // 0x37 '7'
{1058, 27, 46, 32, 2, -48 }, // 0x38 '8'
{1214, 27, 46, 32, 2, -48 }, // 0x39 '9'
{1370, 7, 28, 32, 14, -38 }, // 0x3A ':'
};
const GFXfont FreeSevenSegNumFontPlusPlus PROGMEM = {
(uint8_t *)FreeSevenSegNumFontPlusPlusBitmaps,
(GFXglyph *)FreeSevenSegNumFontPlusPlusGlyphs,
46, 59, 50
};
// FreeSevenSegNumFontPlusPlus bitmap size = 1395 [1525] [2617]
libraries/MCUFRIEND_kbv/MCUFRIEND_kbv.cpp
+3090
View File
File diff suppressed because it is too large. Load diff
libraries/MCUFRIEND_kbv/MCUFRIEND_kbv.h
+77
View File
@@ -0,0 +1,77 @@
/*
* MCUFRIEND_kbv class inherits from Adafruit_GFX class and the Arduino Print class.
* Any use of MCUFRIEND_kbv class and examples is dependent on Adafruit and Arduino licenses
* The license texts are in the accompanying license.txt file
*/
#ifndef MCUFRIEND_KBV_H_
#define MCUFRIEND_KBV_H_ 300
//#define USE_SERIAL
#if ARDUINO < 101
#define USE_GFX_KBV
#include "ADA_GFX_kbv.h"
#else
#include "Adafruit_GFX.h"
#endif
class MCUFRIEND_kbv : public Adafruit_GFX {
public:
// MCUFRIEND_kbv(int CS=A3, int RS=A2, int WR=A1, int RD=A0, int RST=A4); //shield wiring
MCUFRIEND_kbv(int CS=0, int RS=0, int WR=0, int RD=0, int _RST=0); //dummy arguments
void reset(void); // you only need the constructor
void begin(uint16_t ID = 0x9341); // you only need the constructor
virtual void drawPixel(int16_t x, int16_t y, uint16_t color); // and these three
void WriteCmdData(uint16_t cmd, uint16_t dat); // ?public methods !!!
void pushCommand(uint16_t cmd, uint8_t * block, int8_t N);
uint16_t color565(uint8_t r, uint8_t g, uint8_t b) { return ((r & 0xF8) << 8) | ((g & 0xFC) << 3) | ((b & 0xF8) >> 3); }
uint16_t readID(void);
virtual void fillRect(int16_t x, int16_t y, int16_t w, int16_t h, uint16_t color);
virtual void drawFastVLine(int16_t x, int16_t y, int16_t h, uint16_t color) { fillRect(x, y, 1, h, color); }
virtual void drawFastHLine(int16_t x, int16_t y, int16_t w, uint16_t color) { fillRect(x, y, w, 1, color); }
virtual void fillScreen(uint16_t color) { fillRect(0, 0, _width, _height, color); }
virtual void setRotation(uint8_t r);
virtual void invertDisplay(bool i);
uint16_t readReg(uint16_t reg, int8_t index=0);
int16_t readGRAM(int16_t x, int16_t y, uint16_t *block, int16_t w, int16_t h);
uint16_t readPixel(int16_t x, int16_t y) { uint16_t color; readGRAM(x, y, &color, 1, 1); return color; }
void setAddrWindow(int16_t x, int16_t y, int16_t x1, int16_t y1);
void pushColors(uint16_t *block, int16_t n, bool first);
void pushColors(uint8_t *block, int16_t n, bool first);
void pushColors(const uint8_t *block, int16_t n, bool first, bool bigend = false);
void vertScroll(int16_t top, int16_t scrollines, int16_t offset);
protected:
uint32_t readReg32(uint16_t reg);
uint32_t readReg40(uint16_t reg);
uint16_t _lcd_xor, _lcd_capable;
private:
uint16_t _lcd_ID, _lcd_rev, _lcd_madctl, _lcd_drivOut, _MC, _MP, _MW, _SC, _EC, _SP, _EP;
};
// New color definitions. thanks to Bodmer
#define TFT_BLACK 0x0000 /* 0, 0, 0 */
#define TFT_NAVY 0x000F /* 0, 0, 128 */
#define TFT_DARKGREEN 0x03E0 /* 0, 128, 0 */
#define TFT_DARKCYAN 0x03EF /* 0, 128, 128 */
#define TFT_MAROON 0x7800 /* 128, 0, 0 */
#define TFT_PURPLE 0x780F /* 128, 0, 128 */
#define TFT_OLIVE 0x7BE0 /* 128, 128, 0 */
#define TFT_LIGHTGREY 0xC618 /* 192, 192, 192 */
#define TFT_DARKGREY 0x7BEF /* 128, 128, 128 */
#define TFT_BLUE 0x001F /* 0, 0, 255 */
#define TFT_GREEN 0x07E0 /* 0, 255, 0 */
#define TFT_CYAN 0x07FF /* 0, 255, 255 */
#define TFT_RED 0xF800 /* 255, 0, 0 */
#define TFT_MAGENTA 0xF81F /* 255, 0, 255 */
#define TFT_YELLOW 0xFFE0 /* 255, 255, 0 */
#define TFT_WHITE 0xFFFF /* 255, 255, 255 */
#define TFT_ORANGE 0xFDA0 /* 255, 180, 0 */
#define TFT_GREENYELLOW 0xB7E0 /* 180, 255, 0 */
#define TFT_PINK 0xFC9F
#endif
libraries/MCUFRIEND_kbv/README.md
+30
View File
@@ -0,0 +1,30 @@
#MCUFRIEND_kbv
Library for Uno 2.4, 2.8, 3.5, 3.6, 3.95 inch mcufriend Shields
1. The Arduino Library Manager should find and install MCUFRIEND_kbv library
2. Install the Adafruit_GFX library if not already in your User libraries.
3. Insert your Mcufriend style display shield into UNO. Only 28-pin shields are supported.
4. Build any of the Examples from the File->Examples->Mcufriend_kbv menu. e.g.
graphictest_kbv.ino: shows all the methods.
LCD_ID_readreg.ino: diagnostic check to identify unsupported controllers.
MCUFRIEND_kbv inherits all the methods from
the Adafruit_GFX class: https://learn.adafruit.com/adafruit-gfx-graphics-library/overview
and Print class: https://www.arduino.cc/en/Serial/Print
The only "new" methods are hardware related:
vertScroll(), readGRAM(), readPixel(), setAddrWindow(), pushColors(), readID(), begin()
readReg(), pushCommand() access the controller registers
The File layout changed with v2.9.3. If replacing a pre-v2.9.3 library:
Please leave IDE. Delete the existing MCUFRIEND_kbv folder. Start the IDE. Install from Library Manager.
HOW TO INSTALL AND USE: is now in "mcufriend_how_to.txt"
CHANGE HISTORY: is now in "mcufriend_history.txt"
libraries/MCUFRIEND_kbv/TFT_PRINTGLUE.h
+233
View File
@@ -0,0 +1,233 @@
// NOT FOR PUBLIC USE
//#include <Adafruit_GFX.h> // Core graphics library
#include <MCUFRIEND_kbv.h> // Hardware-specific library
#if !defined(AVR)
#include <avr/dtostrf.h>
#endif
#include <Fonts/FreeSans9pt7b.h>
#include <Fonts/FreeSans12pt7b.h>
#include <Fonts/FreeSans18pt7b.h>
#include <FreeSevenSegNumFontPlusPlus.h>
#include <Fonts/FreeMonoBold24pt7b.h>
const GFXfont *Fonts[] = {
NULL,
NULL,
&FreeSans9pt7b, //FONT2
NULL,
&FreeSans12pt7b, //FONT4
NULL,
&FreeSans18pt7b, //FONT6
&FreeSevenSegNumFontPlusPlus, //FONT7
&FreeSevenSegNumFontPlusPlus, //FONT8
// &FreeMonoBold24pt7b, //FONT8
};
//These enumerate the text plotting alignment (reference datum point)
#define TL_DATUM 0 // Top left (default)
#define TC_DATUM 1 // Top centre
#define TR_DATUM 2 // Top right
#define ML_DATUM 3 // Middle left
#define CL_DATUM 3 // Centre left, same as above
#define MC_DATUM 4 // Middle centre
#define CC_DATUM 4 // Centre centre, same as above
#define MR_DATUM 5 // Middle right
#define CR_DATUM 5 // Centre right, same as above
#define BL_DATUM 6 // Bottom left
#define BC_DATUM 7 // Bottom centre
#define BR_DATUM 8 // Bottom right
#define L_BASELINE 9 // Left character baseline (Line the 'A' character would sit on)
#define C_BASELINE 10 // Centre character baseline
#define R_BASELINE 11 // Right character baseline
class TFT_PRINTGLUE : public MCUFRIEND_kbv
{
public:
TFT_PRINTGLUE() {}
void begin(void) {
init();
}
void init(void)
{
MCUFRIEND_kbv::reset();
_ID = MCUFRIEND_kbv::readID();
if (_ID == 0xD3D3) _ID = 0x9486;
MCUFRIEND_kbv::begin(_ID);
MCUFRIEND_kbv::setRotation(1);
_first = true;
_datum = TL_DATUM;
}
void setWindow(int16_t x0, int16_t y0, int16_t x1, int16_t y1)
{
MCUFRIEND_kbv::setAddrWindow(x0, y0, x1, y1);
_first = true;
}
void pushColors(uint8_t *data, uint16_t len)
{
MCUFRIEND_kbv::pushColors((uint8_t*)data, len, _first);
_first = false;
}
void pushColors(uint16_t *data, uint8_t len)
{
MCUFRIEND_kbv::pushColors((uint16_t*)data, len, _first);
_first = false;
}
void pushColors(uint16_t *data, uint16_t len, int first)
{
MCUFRIEND_kbv::pushColors((uint16_t*)data, len, first);
}
void pushColor(uint16_t color)
{
uint16_t c = color;
MCUFRIEND_kbv::pushColors(&c, 1, _first);
_first = false;
}
void setCursor(int16_t x, int16_t y, uint8_t idx = 255)
{
if (idx == 255) idx = _font; //use current font
setTextFont(idx);
MCUFRIEND_kbv::setCursor(x, y + _ydatum);
}
void setFreeFont(const GFXfont *pfont)
{
_font = 1;
_ascent = 7;
_descent = 1;
MCUFRIEND_kbv::setFont(_pfont = pfont);
if (pfont != NULL) {
int16_t x = 0, y = 0, x1, y1 = 0, x2, y2 = 0;
MCUFRIEND_kbv::setTextSize(1);
charBounds('0', &x, &y, &x1, &y1, &x2, &y2);
_ascent = y2 - y1; //yAdvance
GFXfont f;
memcpy_P(&f, _pfont, sizeof(f));
if (f.last >= '{' && '{' >= f.first) {
charBounds('{', &x, &y, &x1, &y1, &x2, &y2);
_descent = y2 - y1 + 1 - _ascent; //
}
}
setTextDatum(_datum);
}
int16_t drawNumber(long long_num, int16_t poX, int16_t poY, uint8_t idx)
{
char buf[12];
ltoa(long_num, buf, 10);
return drawString(buf, poX, poY, idx);
}
int16_t drawChar(char c, int16_t poX, int16_t poY, uint8_t idx)
{
char buf[2];
buf[0] = c;
buf[1] = 0;
return drawString(buf, poX, poY, idx);
}
int16_t drawString(const char *string, int16_t poX, int16_t poY, uint8_t idx)
{
int16_t x1, y1;
uint16_t w, h;
setTextFont(idx);
getTextBounds(string, 0, 50, &x1, &y1, &w, &h); //assume no newlines
w += x1;
x1 = poX;
uint16_t xpad = (_padding > w) ? _padding : w;
switch (_datum) {
case TC_DATUM:
case MC_DATUM:
case BC_DATUM:
case C_BASELINE:
poX -= w / 2;
x1 -= xpad / 2;
break;
case TR_DATUM:
case MR_DATUM:
case BR_DATUM:
case R_BASELINE:
poX -= w;
x1 -= xpad;
break;
}
if (textcolor != textbgcolor) fillRect(x1, poY + _ydatum - _ascent, xpad, _ascent + _descent, textbgcolor);
MCUFRIEND_kbv::setCursor(poX, poY + _ydatum);
print(string);
return w;
}
int16_t drawCentreString(const char *string, int16_t poX, int16_t poY, uint8_t idx)
{
uint8_t datum = _datum;
setTextDatum(TC_DATUM);
uint16_t len = drawString(string, poX, poY, idx);
setTextDatum(datum);
return len;
}
int16_t drawRightString(const char *string, int16_t poX, int16_t poY, uint8_t idx)
{
uint8_t datum = _datum;
setTextDatum(TR_DATUM);
uint16_t len = drawString(string, poX, poY, idx);
setTextDatum(datum);
return len;
}
int16_t drawFloat(float fp_num, uint8_t dec, int16_t poX, int16_t poY, int16_t idx)
{
char buf[12];
dtostrf(fp_num, 0, dec, buf);
return drawString(buf, poX, poY, idx);
}
void setTextDatum(uint8_t datum) {
_padding = 0;
switch (_datum = datum) {
case TL_DATUM:
case TR_DATUM:
case TC_DATUM:
_ydatum = _ascent;
break;
case ML_DATUM:
case MR_DATUM:
case MC_DATUM:
_ydatum = _ascent / 2;
break;
case BL_DATUM:
case BR_DATUM:
case BC_DATUM:
_ydatum = -_descent;
break;
case L_BASELINE:
case R_BASELINE:
case C_BASELINE:
_ydatum = 0;
break;
}
}
void setTextPadding(uint16_t x_width) {
_padding = x_width;
}
uint8_t fontHeight(uint8_t idx) {
GFXfont f;
memcpy_P(&f, _pfont, sizeof(f));
return f.yAdvance;
}
void setTextFont(uint8_t idx)
{
if (_font == idx) return;
_font = idx;
setFreeFont(Fonts[_font]);
}
private:
uint16_t _ID, _padding;
uint8_t _font, _first, _datum, _ascent, _descent;
int8_t _ydatum;
const GFXfont *_pfont;
};
libraries/MCUFRIEND_kbv/UTFTGLUE.h
+198
View File
@@ -0,0 +1,198 @@
/*
* utftglue.h @@@@@@@@@@@@@@@@@@@@@@@@ LIBRARY @@@@@@@@@@@@@@@@@@@@@@@@@
*
* Created: 12/05/2019 14:25:06
* Author: David Prentice
*
* 1. replace "UTFT.h" with "UTFTGLUE.h"
* 2. replace UTFT constructor with UTFTGLUE(model_ID, 0,0,0,0,0)
* 3. remove smallFont, BigFont, SeveSegNumFont declarations
* 4. UTFTGLUE uses FreeFonts or NULL (System 5x7)
*
* 5. knows FreeSmallFont, FreeBigFont and FreeSevenSegNumFont
* 6. any other Fonts just need to #include "FreeOtherXXX.h"
* 7. #define OtherXXX &FreeOtherXXX
*/
#warning @@@@@@@@@@@@@@@@@@@@@@@@@ <UTFTGLUE.h> @@@@@@@@@@@@@@@@@@@@@@@@@@
#ifndef UTFTGLUE_H_
#define UTFTGLUE_H_
#define LEFT 0
#define RIGHT 9999
#define CENTER 9998
#define PORTRAIT 0
#define LANDSCAPE 1
#include <MCUFRIEND_kbv.h>
#include <Adafruit_GFX.h>
#if defined(__arm__) && !defined(TEENSYDUINO)
#include <avr/dtostrf.h>
#endif
#include <FreeDefaultFonts.h>
#define SmallFont &FreeSmallFont
#define BigFont &FreeBigFont
#define SevenSegNumFont &FreeSevenSegNumFont
class UTFTGLUE : public MCUFRIEND_kbv
{
public:
// UTFTGLUE() : MCUFRIEND_kbv() {}
UTFTGLUE(int model_ID, int RS, int WR,int CS, int RST, int RD = A0)
: MCUFRIEND_kbv(CS, RS, WR, RD, RST) { _model_ID = model_ID; }
void InitLCD(byte orientation=LANDSCAPE) {
MCUFRIEND_kbv::reset();
uint16_t ID = MCUFRIEND_kbv::readID();
// if (ID == 0) ID = 0x9341; //DealExtreme with EXTC=0
// if (ID == 0x8989) ID = 0x1289;
// if (ID == 0xD3D3) ID = 0x9481; //write-only controller
// if (ID == 0xD3D3) ID = 0x9486; //write-only controller
if (ID == 0xD3D3) ID = 0x9090; //write-only controller HX8357-D
// if (ID == 0x9327 && orientation == LANDSCAPE) orientation = 3;
MCUFRIEND_kbv::begin(ID);
MCUFRIEND_kbv::setRotation(_orient = orientation);
_radius = 4;
}
void clrScr() { MCUFRIEND_kbv::fillScreen(0x0000);}
void drawPixel(int x, int y) { MCUFRIEND_kbv::drawPixel(x, y, _fcolor);}
void drawLine(int x1, int y1, int x2, int y2) { MCUFRIEND_kbv::drawLine(x1, y1, x2, y2, _fcolor);}
void fillScr(uint16_t color) { MCUFRIEND_kbv::fillScreen(color);}
void fillScr(byte r, byte g, byte b) { MCUFRIEND_kbv::fillScreen(setrgb(r, g, b));}
void drawRect(int x1, int y1, int x2, int y2) {
int w = x2 - x1 + 1, h = y2 - y1 + 1;
if (w < 0) { x1 = x2; w = -w; }
if (h < 0) { y1 = y2; h = -h; }
MCUFRIEND_kbv::drawRect(x1, y1, w, h, _fcolor);
}
void drawRoundRect(int x1, int y1, int x2, int y2) {
int w = x2 - x1 + 1, h = y2 - y1 + 1;
if (w < 0) { x1 = x2; w = -w; }
if (h < 0) { y1 = y2; h = -h; }
MCUFRIEND_kbv::drawRoundRect(x1, y1, w, h, _radius, _fcolor);
}
void fillRect(int x1, int y1, int x2, int y2) {
int w = x2 - x1 + 1, h = y2 - y1 + 1;
if (w < 0) { x1 = x2; w = -w; }
if (h < 0) { y1 = y2; h = -h; }
MCUFRIEND_kbv::fillRect(x1, y1, w, h, _fcolor);
}
void fillRoundRect(int x1, int y1, int x2, int y2) {
int w = x2 - x1 + 1, h = y2 - y1 + 1;
if (w < 0) { x1 = x2; w = -w; }
if (h < 0) { y1 = y2; h = -h; }
MCUFRIEND_kbv::fillRoundRect(x1, y1, w, h, _radius, _fcolor);
}
void drawCircle(int x, int y, int radius) { MCUFRIEND_kbv::drawCircle(x, y, radius, _fcolor);}
void fillCircle(int x, int y, int radius) { MCUFRIEND_kbv::fillCircle(x, y, radius, _fcolor);}
void setColor(byte r, byte g, byte b) { setColor(setrgb(r, g, b));}
void setColor(uint16_t c) { MCUFRIEND_kbv::setTextColor(_fcolor = c, _bcolor); }
void setBackColor(byte r, byte g, byte b) { setBackColor(setrgb(r, g, b)); }
void setBackColor(uint32_t c) {
if (c == 0xFFFFFFFF) _bcolor = _fcolor;
else _bcolor = c;
MCUFRIEND_kbv::setTextColor(_fcolor, _bcolor);
}
void print(const char *st, int x, int y, int deg=0) {
settextcursor((char*)st, x, y); MCUFRIEND_kbv::print(st);}
void print(char *st, int x, int y, int deg=0) {
settextcursor(st, x, y); MCUFRIEND_kbv::print(st);}
void print(String st, int x, int y, int deg=0) {
settextcursor((char*)(st.c_str()), x, y); MCUFRIEND_kbv::print(st);}
void printNumI(long num, int x, int y, int length=0, char filler=' ') {
printNumF(num, 0, x, y, '.', length, filler);
}
void printNumF(double num, byte dec, int x, int y, char divider='.', int length=0, char filler=' ') {
char buf[20];
dtostrf(num, length, dec, buf);
for (int i = 0; buf[i] == ' '; i++) buf[i] = filler;
settextcursor(buf, x, y, length * _dig_wid * MCUFRIEND_kbv::textsize_x);
MCUFRIEND_kbv::print(buf);
}
void setTextSize(int sz) { MCUFRIEND_kbv::setTextSize(gfxFont == NULL ? sz : 1); } // ####### GFX ########
void setFont(const GFXfont* font) {
MCUFRIEND_kbv::setFont(font);
_ascend = 8;
_descend = 1;
_dig_wid = 6;
if (font != NULL) {
int16_t x = 0, y = 0, x1, y1 = 0, x2, y2 = 0;
MCUFRIEND_kbv::setTextSize(1);
charBounds('0', &x, &y, &x1, &y1, &x2, &y2);
_ascend = y2 - y1; //yAdvance
_dig_wid = x; //xAdvance
}
}
void drawBitmap(int x, int y, int sx, int sy, const uint16_t *data, int scale=1) {
uint16_t color;
MCUFRIEND_kbv::setAddrWindow(x, y, x + sx*scale - 1, y + sy*scale - 1);
if (scale == 1) MCUFRIEND_kbv::pushColors((const uint8_t*)data, sx * sy, 1);
else {
for (int row = 0; row < sy; row++) {
for (int col = 0; col < sx; col++) {
color = pgm_read_word(data + (row*sx + col)*1);
MCUFRIEND_kbv::fillRect(x+col*scale, y+row*scale, scale, scale, color);
}
}
}
}
// void drawBitmap(int x, int y, int sx, int sy, bitmapdatatype data, int deg, int rox, int roy);
// void lcdOff();
// void lcdOn();
void setContrast(char c) {}
int getDisplayXSize() { return MCUFRIEND_kbv::width(); }
int getDisplayYSize() { return MCUFRIEND_kbv::height(); }
void setBrightness(byte br) {}
// void LCD_Write_DATA(char VH,char VL);
// void dispBitmap(File inFile);
uint8_t _ascend, _descend, _dig_wid;
uint16_t _model_ID;
protected:
uint16_t _fcolor;
uint16_t _bcolor;
// uint8_t _ascend, _descend, _dig_wid;
uint8_t _radius;
uint8_t _orient;
void settextcursor(char *st, int x, int y, int pad = 0) {
int16_t pos, x1, y1;
uint16_t len, w, h;
bool is_gfx = (MCUFRIEND_kbv::gfxFont != NULL);
getTextBounds(st, 0, 0, &x1, &y1, &w, &h); //always
len = x1 + w + 0; // assumes the final right padding = 1.
if (pad >= len) pad = pad - len;
pos = (MCUFRIEND_kbv::width() - len - pad);
if (x == CENTER) x = pos/2;
else if (x == RIGHT) x = pos - 1;
if (is_gfx) { //only GFX fonts need to paint background
h = _ascend + _descend; //pgm_read_byte(&gfxFont->yAdvance);
if (_fcolor != _bcolor) MCUFRIEND_kbv::fillRect(x, y, len + pad + 1, h, _bcolor);
y += h;
}
MCUFRIEND_kbv::setCursor(x + pad, y);
}
uint16_t setrgb(byte r, byte g, byte b) { return ((r&0xF8) << 8) | ((g&0xFC) << 3) | (b>>3);}
};
#define VGA_BLACK 0x0000
#define VGA_WHITE 0xFFFF
#define VGA_RED 0xF800
#define VGA_GREEN 0x0400
#define VGA_BLUE 0x001F
#define VGA_SILVER 0xC618
#define VGA_GRAY 0x8410
#define VGA_MAROON 0x8000
#define VGA_YELLOW 0xFFE0
#define VGA_OLIVE 0x8400
#define VGA_LIME 0x07E0
#define VGA_AQUA 0x07FF
#define VGA_TEAL 0x0410
#define VGA_NAVY 0x0010
#define VGA_FUCHSIA 0xF81F
#define VGA_PURPLE 0x8010
#define VGA_TRANSPARENT 0xFFFFFFFF
#endif /* UTFTGLUE_H_ */
libraries/MCUFRIEND_kbv/examples/Font_simple/Font_simple.ino
+68
View File
@@ -0,0 +1,68 @@
#include <Adafruit_GFX.h> // Core graphics library
#include <MCUFRIEND_kbv.h> // Hardware-specific library
MCUFRIEND_kbv tft;
#include <Fonts/FreeSans9pt7b.h>
#include <Fonts/FreeSans12pt7b.h>
#include <Fonts/FreeSerif12pt7b.h>
#include <FreeDefaultFonts.h>
#define BLACK 0x0000
#define RED 0xF800
#define GREEN 0x07E0
#define WHITE 0xFFFF
#define GREY 0x8410
void setup(void)
{
Serial.begin(9600);
uint16_t ID = tft.readID();
Serial.println("Example: Font_simple");
Serial.print("found ID = 0x");
Serial.println(ID, HEX);
if (ID == 0xD3D3) ID = 0x9481; //force ID if write-only display
tft.begin(ID);
tft.setRotation(0);
}
void loop(void)
{
tft.fillScreen(BLACK);
showmsgXY(20, 10, 1, NULL, "System x1");
showmsgXY(20, 24, 2, NULL, "System x2");
showmsgXY(20, 60, 1, &FreeSans9pt7b, "FreeSans9pt7b");
showmsgXY(20, 80, 1, &FreeSans12pt7b, "FreeSans12pt7b");
showmsgXY(20, 100, 1, &FreeSerif12pt7b, "FreeSerif12pt7b");
showmsgXY(20, 120, 1, &FreeSmallFont, "FreeSmallFont");
showmsgXY(5, 180, 1, &FreeSevenSegNumFont, "01234");
showmsgXY(5, 190, 1, NULL, "System Font is drawn from topline");
tft.setTextColor(RED, GREY);
tft.setTextSize(2);
tft.setCursor(0, 220);
tft.print("7x5 can overwrite");
delay(1000);
tft.setCursor(0, 220);
tft.print("if background set");
delay(1000);
showmsgXY(5, 260, 1, &FreeSans9pt7b, "Free Fonts from baseline");
showmsgXY(5, 285, 1, &FreeSans9pt7b, "Free Fonts transparent");
delay(1000);
showmsgXY(5, 285, 1, &FreeSans9pt7b, "Free Fonts XXX");
delay(1000);
showmsgXY(5, 310, 1, &FreeSans9pt7b, "erase backgnd with fillRect()");
delay(10000);
}
void showmsgXY(int x, int y, int sz, const GFXfont *f, const char *msg)
{
int16_t x1, y1;
uint16_t wid, ht;
tft.drawFastHLine(0, y, tft.width(), WHITE);
tft.setFont(f);
tft.setCursor(x, y);
tft.setTextColor(GREEN);
tft.setTextSize(sz);
tft.print(msg);
delay(1000);
}
libraries/MCUFRIEND_kbv/examples/GLUE_Demo_220x176/GLUE_Demo_220x176.ino
+342
View File
@@ -0,0 +1,342 @@
// UTFT_Demo_220x176
// Copyright (C)2015 Rinky-Dink Electronics, Henning Karlsen. All right reserved
// web: http://www.RinkyDinkElectronics.com/
//
// This program is a demo of how to use most of the functions
// of the library with a supported display modules.
//
// This demo was made for modules with a screen resolution
// of 220x176 pixels.
//
// This program requires the UTFT library.
//
//################################################
// GLUE class that implements the UTFT API
// replace UTFT include and constructor statements
// remove UTFT font declaration e.g. SmallFont
//################################################
#include <UTFTGLUE.h> //use GLUE class and constructor
UTFTGLUE myGLCD(0,A2,A1,A3,A4,A0); //all dummy args
// Declare which fonts we will be using
//extern uint8_t SmallFont[]; //GLUE defines as GFXFont ref
// Set the pins to the correct ones for your development shield
// ------------------------------------------------------------
// Arduino Uno / 2009:
// -------------------
// Standard Arduino Uno/2009 shield : <display model>,A5,A4,A3,A2
// DisplayModule Arduino Uno TFT shield : <display model>,A5,A4,A3,A2
//
// Arduino Mega:
// -------------------
// Standard Arduino Mega/Due shield : <display model>,38,39,40,41
// CTE TFT LCD/SD Shield for Arduino Mega : <display model>,38,39,40,41
//
// Remember to change the model parameter to suit your display module!
//UTFT myGLCD(ITDB22,A5,A4,A3,A2);
void setup()
{
randomSeed(analogRead(0));
// Setup the LCD
myGLCD.InitLCD();
myGLCD.setFont(SmallFont);
}
void loop()
{
int buf[218];
int x, x2;
int y, y2;
int r;
// Clear the screen and draw the frame
myGLCD.clrScr();
myGLCD.setColor(255, 0, 0);
myGLCD.fillRect(0, 0, 219, 13);
myGLCD.setColor(64, 64, 64);
myGLCD.fillRect(0, 162, 219, 175);
myGLCD.setColor(255, 255, 255);
myGLCD.setBackColor(255, 0, 0);
myGLCD.print("** Universal TFT Library **", CENTER, 1);
myGLCD.setBackColor(64, 64, 64);
myGLCD.setColor(255,255,0);
myGLCD.print("> Rinky-Dink Electronics <", CENTER, 163);
myGLCD.setColor(0, 0, 255);
myGLCD.drawRect(0, 14, 219, 161);
// Draw crosshairs
myGLCD.setColor(0, 0, 255);
myGLCD.setBackColor(0, 0, 0);
myGLCD.drawLine(109, 15, 109, 160);
myGLCD.drawLine(1, 88, 218, 88);
for (int i=9; i<210; i+=10)
myGLCD.drawLine(i, 86, i, 90);
for (int i=19; i<155; i+=10)
myGLCD.drawLine(107, i, 111, i);
// Draw sin-, cos- and tan-lines
myGLCD.setColor(0,255,255);
myGLCD.print("Sin", 5, 15);
for (int i=1; i<218; i++)
{
myGLCD.drawPixel(i,88+(sin(((i*1.65)*3.14)/180)*70));
}
myGLCD.setColor(255,0,0);
myGLCD.print("Cos", 5, 27);
for (int i=1; i<218; i++)
{
myGLCD.drawPixel(i,88+(cos(((i*1.65)*3.14)/180)*70));
}
myGLCD.setColor(255,255,0);
myGLCD.print("Tan", 5, 39);
for (int i=1; i<218; i++)
{
myGLCD.drawPixel(i,88+(tan(((i*1.65)*3.14)/180)));
}
delay(2000);
myGLCD.setColor(0,0,0);
myGLCD.fillRect(1,15,218,160);
myGLCD.setColor(0, 0, 255);
myGLCD.setBackColor(0, 0, 0);
myGLCD.drawLine(109, 15, 109, 160);
myGLCD.drawLine(1, 88, 218, 88);
// Draw a moving sinewave
x=1;
for (int i=1; i<(218*20); i++)
{
x++;
if (x==219)
x=1;
if (i>219)
{
if ((x==109)||(buf[x-1]==88))
myGLCD.setColor(0,0,255);
else
myGLCD.setColor(0,0,0);
myGLCD.drawPixel(x,buf[x-1]);
}
myGLCD.setColor(0,255,255);
y=88+(sin(((i*1.6)*3.14)/180)*(65-(i / 100)));
myGLCD.drawPixel(x,y);
buf[x-1]=y;
}
delay(2000);
myGLCD.setColor(0,0,0);
myGLCD.fillRect(1,15,218,160);
// Draw some filled rectangles
for (int i=1; i<6; i++)
{
switch (i)
{
case 1:
myGLCD.setColor(255,0,255);
break;
case 2:
myGLCD.setColor(255,0,0);
break;
case 3:
myGLCD.setColor(0,255,0);
break;
case 4:
myGLCD.setColor(0,0,255);
break;
case 5:
myGLCD.setColor(255,255,0);
break;
}
myGLCD.fillRect(44+(i*15), 23+(i*15), 88+(i*15), 63+(i*15));
}
delay(2000);
myGLCD.setColor(0,0,0);
myGLCD.fillRect(1,15,218,160);
// Draw some filled, rounded rectangles
for (int i=1; i<6; i++)
{
switch (i)
{
case 1:
myGLCD.setColor(255,0,255);
break;
case 2:
myGLCD.setColor(255,0,0);
break;
case 3:
myGLCD.setColor(0,255,0);
break;
case 4:
myGLCD.setColor(0,0,255);
break;
case 5:
myGLCD.setColor(255,255,0);
break;
}
myGLCD.fillRoundRect(132-(i*15), 23+(i*15), 172-(i*15), 63+(i*15));
}
delay(2000);
myGLCD.setColor(0,0,0);
myGLCD.fillRect(1,15,218,160);
// Draw some filled circles
for (int i=1; i<6; i++)
{
switch (i)
{
case 1:
myGLCD.setColor(255,0,255);
break;
case 2:
myGLCD.setColor(255,0,0);
break;
case 3:
myGLCD.setColor(0,255,0);
break;
case 4:
myGLCD.setColor(0,0,255);
break;
case 5:
myGLCD.setColor(255,255,0);
break;
}
myGLCD.fillCircle(64+(i*15),43+(i*15), 20);
}
delay(2000);
myGLCD.setColor(0,0,0);
myGLCD.fillRect(1,15,218,160);
// Draw some lines in a pattern
myGLCD.setColor (255,0,0);
for (int i=15; i<160; i+=5)
{
myGLCD.drawLine(1, i, (i*1.44)-10, 160);
}
myGLCD.setColor (255,0,0);
for (int i=160; i>15; i-=5)
{
myGLCD.drawLine(218, i, (i*1.44)-12, 15);
}
myGLCD.setColor (0,255,255);
for (int i=160; i>15; i-=5)
{
myGLCD.drawLine(1, i, 232-(i*1.44), 15);
}
myGLCD.setColor (0,255,255);
for (int i=15; i<160; i+=5)
{
myGLCD.drawLine(218, i, 231-(i*1.44), 160);
}
delay(2000);
myGLCD.setColor(0,0,0);
myGLCD.fillRect(1,15,218,160);
// Draw some random circles
for (int i=0; i<100; i++)
{
myGLCD.setColor(random(255), random(255), random(255));
x=22+random(176);
y=35+random(105);
r=random(20);
myGLCD.drawCircle(x, y, r);
}
delay(2000);
myGLCD.setColor(0,0,0);
myGLCD.fillRect(1,15,218,160);
// Draw some random rectangles
for (int i=0; i<100; i++)
{
myGLCD.setColor(random(255), random(255), random(255));
x=2+random(216);
y=16+random(143);
x2=2+random(216);
y2=16+random(143);
myGLCD.drawRect(x, y, x2, y2);
}
delay(2000);
myGLCD.setColor(0,0,0);
myGLCD.fillRect(1,15,218,160);
// Draw some random rounded rectangles
for (int i=0; i<100; i++)
{
myGLCD.setColor(random(255), random(255), random(255));
x=2+random(216);
y=16+random(143);
x2=2+random(216);
y2=16+random(143);
myGLCD.drawRoundRect(x, y, x2, y2);
}
delay(2000);
myGLCD.setColor(0,0,0);
myGLCD.fillRect(1,15,218,160);
for (int i=0; i<100; i++)
{
myGLCD.setColor(random(255), random(255), random(255));
x=2+random(216);
y=16+random(143);
x2=2+random(216);
y2=16+random(143);
myGLCD.drawLine(x, y, x2, y2);
}
delay(2000);
myGLCD.setColor(0,0,0);
myGLCD.fillRect(1,15,218,160);
for (int i=0; i<10000; i++)
{
myGLCD.setColor(random(255), random(255), random(255));
myGLCD.drawPixel(2+random(216), 16+random(143));
}
delay(2000);
myGLCD.fillScr(0, 0, 255);
myGLCD.setColor(255, 0, 0);
myGLCD.fillRoundRect(40, 57, 179, 119);
myGLCD.setColor(255, 255, 255);
myGLCD.setBackColor(255, 0, 0);
myGLCD.print("That's it!", CENTER, 62);
myGLCD.print("Restarting in a", CENTER, 88);
myGLCD.print("few seconds...", CENTER, 101);
myGLCD.setColor(0, 255, 0);
myGLCD.setBackColor(0, 0, 255);
myGLCD.print("Runtime: (msecs)", CENTER, 146);
myGLCD.printNumI(millis(), CENTER, 161);
delay (10000);
}
libraries/MCUFRIEND_kbv/examples/GLUE_Demo_320x240/GLUE_Demo_320x240.ino
+341
View File
@@ -0,0 +1,341 @@
// UTFT_Demo_320x240
// Copyright (C)2015 Rinky-Dink Electronics, Henning Karlsen. All right reserved
// web: http://www.RinkyDinkElectronics.com/
//
// This program is a demo of how to use most of the functions
// of the library with a supported display modules.
//
// This demo was made for modules with a screen resolution
// of 320x240 pixels.
//
// This program requires the UTFT library.
//
//################################################
// GLUE class that implements the UTFT API
// replace UTFT include and constructor statements
// remove UTFT font declaration e.g. SmallFont
//################################################
#include <UTFTGLUE.h> //use GLUE class and constructor
UTFTGLUE myGLCD(0,A2,A1,A3,A4,A0); //all dummy args
// Declare which fonts we will be using
//extern uint8_t SmallFont[]; //GLUE defines as GFXFont ref
// Set the pins to the correct ones for your development shield
// ------------------------------------------------------------
// Arduino Uno / 2009:
// -------------------
// Standard Arduino Uno/2009 shield : <display model>,A5,A4,A3,A2
// DisplayModule Arduino Uno TFT shield : <display model>,A5,A4,A3,A2
//
// Arduino Mega:
// -------------------
// Standard Arduino Mega/Due shield : <display model>,38,39,40,41
// CTE TFT LCD/SD Shield for Arduino Mega : <display model>,38,39,40,41
//
// Remember to change the model parameter to suit your display module!
//UTFT myGLCD(ITDB32S,38,39,40,41);
void setup()
{
randomSeed(analogRead(0));
// Setup the LCD
myGLCD.InitLCD();
myGLCD.setFont(SmallFont);
}
void loop()
{
int buf[318];
int x, x2;
int y, y2;
int r;
// Clear the screen and draw the frame
myGLCD.clrScr();
myGLCD.setColor(255, 0, 0);
myGLCD.fillRect(0, 0, 319, 13);
myGLCD.setColor(64, 64, 64);
myGLCD.fillRect(0, 226, 319, 239);
myGLCD.setColor(255, 255, 255);
myGLCD.setBackColor(255, 0, 0);
myGLCD.print("* Universal Color TFT Display Library *", CENTER, 1);
myGLCD.setBackColor(64, 64, 64);
myGLCD.setColor(255,255,0);
myGLCD.print("<http://www.RinkyDinkElectronics.com/>", CENTER, 227);
myGLCD.setColor(0, 0, 255);
myGLCD.drawRect(0, 14, 319, 225);
// Draw crosshairs
myGLCD.setColor(0, 0, 255);
myGLCD.setBackColor(0, 0, 0);
myGLCD.drawLine(159, 15, 159, 224);
myGLCD.drawLine(1, 119, 318, 119);
for (int i=9; i<310; i+=10)
myGLCD.drawLine(i, 117, i, 121);
for (int i=19; i<220; i+=10)
myGLCD.drawLine(157, i, 161, i);
// Draw sin-, cos- and tan-lines
myGLCD.setColor(0,255,255);
myGLCD.print("Sin", 5, 15);
for (int i=1; i<318; i++)
{
myGLCD.drawPixel(i,119+(sin(((i*1.13)*3.14)/180)*95));
}
myGLCD.setColor(255,0,0);
myGLCD.print("Cos", 5, 27);
for (int i=1; i<318; i++)
{
myGLCD.drawPixel(i,119+(cos(((i*1.13)*3.14)/180)*95));
}
myGLCD.setColor(255,255,0);
myGLCD.print("Tan", 5, 39);
for (int i=1; i<318; i++)
{
myGLCD.drawPixel(i,119+(tan(((i*1.13)*3.14)/180)));
}
delay(2000);
myGLCD.setColor(0,0,0);
myGLCD.fillRect(1,15,318,224);
myGLCD.setColor(0, 0, 255);
myGLCD.setBackColor(0, 0, 0);
myGLCD.drawLine(159, 15, 159, 224);
myGLCD.drawLine(1, 119, 318, 119);
// Draw a moving sinewave
x=1;
for (int i=1; i<(318*20); i++)
{
x++;
if (x==319)
x=1;
if (i>319)
{
if ((x==159)||(buf[x-1]==119))
myGLCD.setColor(0,0,255);
else
myGLCD.setColor(0,0,0);
myGLCD.drawPixel(x,buf[x-1]);
}
myGLCD.setColor(0,255,255);
y=119+(sin(((i*1.1)*3.14)/180)*(90-(i / 100)));
myGLCD.drawPixel(x,y);
buf[x-1]=y;
}
delay(2000);
myGLCD.setColor(0,0,0);
myGLCD.fillRect(1,15,318,224);
// Draw some filled rectangles
for (int i=1; i<6; i++)
{
switch (i)
{
case 1:
myGLCD.setColor(255,0,255);
break;
case 2:
myGLCD.setColor(255,0,0);
break;
case 3:
myGLCD.setColor(0,255,0);
break;
case 4:
myGLCD.setColor(0,0,255);
break;
case 5:
myGLCD.setColor(255,255,0);
break;
}
myGLCD.fillRect(70+(i*20), 30+(i*20), 130+(i*20), 90+(i*20));
}
delay(2000);
myGLCD.setColor(0,0,0);
myGLCD.fillRect(1,15,318,224);
// Draw some filled, rounded rectangles
for (int i=1; i<6; i++)
{
switch (i)
{
case 1:
myGLCD.setColor(255,0,255);
break;
case 2:
myGLCD.setColor(255,0,0);
break;
case 3:
myGLCD.setColor(0,255,0);
break;
case 4:
myGLCD.setColor(0,0,255);
break;
case 5:
myGLCD.setColor(255,255,0);
break;
}
myGLCD.fillRoundRect(190-(i*20), 30+(i*20), 250-(i*20), 90+(i*20));
}
delay(2000);
myGLCD.setColor(0,0,0);
myGLCD.fillRect(1,15,318,224);
// Draw some filled circles
for (int i=1; i<6; i++)
{
switch (i)
{
case 1:
myGLCD.setColor(255,0,255);
break;
case 2:
myGLCD.setColor(255,0,0);
break;
case 3:
myGLCD.setColor(0,255,0);
break;
case 4:
myGLCD.setColor(0,0,255);
break;
case 5:
myGLCD.setColor(255,255,0);
break;
}
myGLCD.fillCircle(100+(i*20),60+(i*20), 30);
}
delay(2000);
myGLCD.setColor(0,0,0);
myGLCD.fillRect(1,15,318,224);
// Draw some lines in a pattern
myGLCD.setColor (255,0,0);
for (int i=15; i<224; i+=5)
{
myGLCD.drawLine(1, i, (i*1.44)-10, 224);
}
myGLCD.setColor (255,0,0);
for (int i=224; i>15; i-=5)
{
myGLCD.drawLine(318, i, (i*1.44)-11, 15);
}
myGLCD.setColor (0,255,255);
for (int i=224; i>15; i-=5)
{
myGLCD.drawLine(1, i, 331-(i*1.44), 15);
}
myGLCD.setColor (0,255,255);
for (int i=15; i<224; i+=5)
{
myGLCD.drawLine(318, i, 330-(i*1.44), 224);
}
delay(2000);
myGLCD.setColor(0,0,0);
myGLCD.fillRect(1,15,318,224);
// Draw some random circles
for (int i=0; i<100; i++)
{
myGLCD.setColor(random(255), random(255), random(255));
x=32+random(256);
y=45+random(146);
r=random(30);
myGLCD.drawCircle(x, y, r);
}
delay(2000);
myGLCD.setColor(0,0,0);
myGLCD.fillRect(1,15,318,224);
// Draw some random rectangles
for (int i=0; i<100; i++)
{
myGLCD.setColor(random(255), random(255), random(255));
x=2+random(316);
y=16+random(207);
x2=2+random(316);
y2=16+random(207);
myGLCD.drawRect(x, y, x2, y2);
}
delay(2000);
myGLCD.setColor(0,0,0);
myGLCD.fillRect(1,15,318,224);
// Draw some random rounded rectangles
for (int i=0; i<100; i++)
{
myGLCD.setColor(random(255), random(255), random(255));
x=2+random(316);
y=16+random(207);
x2=2+random(316);
y2=16+random(207);
myGLCD.drawRoundRect(x, y, x2, y2);
}
delay(2000);
myGLCD.setColor(0,0,0);
myGLCD.fillRect(1,15,318,224);
for (int i=0; i<100; i++)
{
myGLCD.setColor(random(255), random(255), random(255));
x=2+random(316);
y=16+random(209);
x2=2+random(316);
y2=16+random(209);
myGLCD.drawLine(x, y, x2, y2);
}
delay(2000);
myGLCD.setColor(0,0,0);
myGLCD.fillRect(1,15,318,224);
for (int i=0; i<10000; i++)
{
myGLCD.setColor(random(255), random(255), random(255));
myGLCD.drawPixel(2+random(316), 16+random(209));
}
delay(2000);
myGLCD.fillScr(0, 0, 255);
myGLCD.setColor(255, 0, 0);
myGLCD.fillRoundRect(80, 70, 239, 169);
myGLCD.setColor(255, 255, 255);
myGLCD.setBackColor(255, 0, 0);
myGLCD.print("That's it!", CENTER, 93);
myGLCD.print("Restarting in a", CENTER, 119);
myGLCD.print("few seconds...", CENTER, 132);
myGLCD.setColor(0, 255, 0);
myGLCD.setBackColor(0, 0, 255);
myGLCD.print("Runtime: (msecs)", CENTER, 210);
myGLCD.printNumI(millis(), CENTER, 225);
delay (10000);
}
libraries/MCUFRIEND_kbv/examples/GLUE_Demo_400x240/GLUE_Demo_400x240.ino
+343
View File
@@ -0,0 +1,343 @@
// UTFT_Demo_400x240
// Copyright (C)2015 Rinky-Dink Electronics, Henning Karlsen. All right reserved
// web: http://www.RinkyDinkElectronics.com/
//
// This program is a demo of how to use most of the functions
// of the library with a supported display modules.
//
// This demo was made for modules with a screen resolution
// of 400x240 pixels.
//
// This program requires the UTFT library.
//
//################################################
// GLUE class that implements the UTFT API
// replace UTFT include and constructor statements
// remove UTFT font declaration e.g. SmallFont
//################################################
#include <UTFTGLUE.h> //use GLUE class and constructor
UTFTGLUE myGLCD(0,A2,A1,A3,A4,A0); //all dummy args
// Declare which fonts we will be using
//extern uint8_t SmallFont[];
// Set the pins to the correct ones for your development shield
// ------------------------------------------------------------
// Arduino Uno / 2009:
// -------------------
// Standard Arduino Uno/2009 shield : <display model>,A5,A4,A3,A2
// DisplayModule Arduino Uno TFT shield : <display model>,A5,A4,A3,A2
//
// Arduino Mega:
// -------------------
// Standard Arduino Mega/Due shield : <display model>,38,39,40,41
// CTE TFT LCD/SD Shield for Arduino Mega : <display model>,38,39,40,41
//
// Remember to change the model parameter to suit your display module!
//UTFT myGLCD(ITDB32WD,38,39,40,41);
void setup()
{
randomSeed(analogRead(0));
// Setup the LCD
myGLCD.InitLCD();
myGLCD.setFont(SmallFont);
}
void loop()
{
int buf[398];
int x, x2;
int y, y2;
int r;
// Clear the screen and draw the frame
myGLCD.clrScr();
myGLCD.setColor(255, 0, 0);
myGLCD.fillRect(0, 0, 399, 13);
myGLCD.setColor(64, 64, 64);
myGLCD.fillRect(0, 226, 399, 239);
myGLCD.setColor(255, 255, 255);
myGLCD.setBackColor(255, 0, 0);
myGLCD.print("*** Universal Color TFT Display Library ***", CENTER, 1);
myGLCD.setBackColor(64, 64, 64);
myGLCD.setColor(255,255,0);
myGLCD.print("< http://www.RinkyDinkElectronics.com/ >", CENTER, 227);
myGLCD.setColor(0, 0, 255);
myGLCD.drawRect(0, 14, 399, 225);
// Draw crosshairs
myGLCD.setColor(0, 0, 255);
myGLCD.setBackColor(0, 0, 0);
myGLCD.drawLine(199, 15, 199, 224);
myGLCD.drawLine(1, 119, 398, 119);
for (int i=9; i<390; i+=10)
myGLCD.drawLine(i, 117, i, 121);
for (int i=19; i<220; i+=10)
myGLCD.drawLine(197, i, 201, i);
// Draw sin-, cos- and tan-lines
myGLCD.setColor(0,255,255);
myGLCD.print("Sin", 5, 15);
for (int i=1; i<398; i++)
{
myGLCD.drawPixel(i,119+(sin(((i*0.9)*3.14)/180)*95));
}
myGLCD.setColor(255,0,0);
myGLCD.print("Cos", 5, 27);
for (int i=1; i<398; i++)
{
myGLCD.drawPixel(i,119+(cos(((i*0.9)*3.14)/180)*95));
}
myGLCD.setColor(255,255,0);
myGLCD.print("Tan", 5, 39);
for (int i=1; i<398; i++)
{
y=119+(tan(((i*0.9)*3.14)/180));
if ((y>15) && (y<224))
myGLCD.drawPixel(i,y);
}
delay(2000);
myGLCD.setColor(0,0,0);
myGLCD.fillRect(1,15,398,224);
myGLCD.setColor(0, 0, 255);
myGLCD.setBackColor(0, 0, 0);
myGLCD.drawLine(199, 15, 199, 224);
myGLCD.drawLine(1, 119, 398, 119);
// Draw a moving sinewave
x=1;
for (int i=1; i<(398*20); i++)
{
x++;
if (x==399)
x=1;
if (i>399)
{
if ((x==199)||(buf[x-1]==119))
myGLCD.setColor(0,0,255);
else
myGLCD.setColor(0,0,0);
myGLCD.drawPixel(x,buf[x-1]);
}
myGLCD.setColor(0,255,255);
y=119+(sin(((i)*3.14)/180)*(90-(i / 100)));
myGLCD.drawPixel(x,y);
buf[x-1]=y;
}
delay(2000);
myGLCD.setColor(0,0,0);
myGLCD.fillRect(1,15,398,224);
// Draw some filled rectangles
for (int i=1; i<6; i++)
{
switch (i)
{
case 1:
myGLCD.setColor(255,0,255);
break;
case 2:
myGLCD.setColor(255,0,0);
break;
case 3:
myGLCD.setColor(0,255,0);
break;
case 4:
myGLCD.setColor(0,0,255);
break;
case 5:
myGLCD.setColor(255,255,0);
break;
}
myGLCD.fillRect(110+(i*20), 30+(i*20), 170+(i*20), 90+(i*20));
}
delay(2000);
myGLCD.setColor(0,0,0);
myGLCD.fillRect(1,15,398,224);
// Draw some filled, rounded rectangles
for (int i=1; i<6; i++)
{
switch (i)
{
case 1:
myGLCD.setColor(255,0,255);
break;
case 2:
myGLCD.setColor(255,0,0);
break;
case 3:
myGLCD.setColor(0,255,0);
break;
case 4:
myGLCD.setColor(0,0,255);
break;
case 5:
myGLCD.setColor(255,255,0);
break;
}
myGLCD.fillRoundRect(230-(i*20), 30+(i*20), 290-(i*20), 90+(i*20));
}
delay(2000);
myGLCD.setColor(0,0,0);
myGLCD.fillRect(1,15,398,224);
// Draw some filled circles
for (int i=1; i<6; i++)
{
switch (i)
{
case 1:
myGLCD.setColor(255,0,255);
break;
case 2:
myGLCD.setColor(255,0,0);
break;
case 3:
myGLCD.setColor(0,255,0);
break;
case 4:
myGLCD.setColor(0,0,255);
break;
case 5:
myGLCD.setColor(255,255,0);
break;
}
myGLCD.fillCircle(110+(i*30),60+(i*20), 30);
}
delay(2000);
myGLCD.setColor(0,0,0);
myGLCD.fillRect(1,15,398,224);
// Draw some lines in a pattern
myGLCD.setColor (255,0,0);
for (int i=15; i<224; i+=5)
{
myGLCD.drawLine(1, i, (i*1.77)-10, 224);
}
myGLCD.setColor (255,0,0);
for (int i=224; i>15; i-=5)
{
myGLCD.drawLine(398, i, (i*1.77)-11, 15);
}
myGLCD.setColor (0,255,255);
for (int i=224; i>15; i-=5)
{
myGLCD.drawLine(1, i, 411-(i*1.77), 15);
}
myGLCD.setColor (0,255,255);
for (int i=15; i<224; i+=5)
{
myGLCD.drawLine(398, i, 410-(i*1.77), 224);
}
delay(2000);
myGLCD.setColor(0,0,0);
myGLCD.fillRect(1,15,398,224);
// Draw some random circles
for (int i=0; i<100; i++)
{
myGLCD.setColor(random(255), random(255), random(255));
x=32+random(336);
y=45+random(146);
r=random(30);
myGLCD.drawCircle(x, y, r);
}
delay(2000);
myGLCD.setColor(0,0,0);
myGLCD.fillRect(1,15,398,224);
// Draw some random rectangles
for (int i=0; i<100; i++)
{
myGLCD.setColor(random(255), random(255), random(255));
x=2+random(396);
y=16+random(207);
x2=2+random(396);
y2=16+random(207);
myGLCD.drawRect(x, y, x2, y2);
}
delay(2000);
myGLCD.setColor(0,0,0);
myGLCD.fillRect(1,15,398,224);
// Draw some random rounded rectangles
for (int i=0; i<100; i++)
{
myGLCD.setColor(random(255), random(255), random(255));
x=2+random(396);
y=16+random(207);
x2=2+random(396);
y2=16+random(207);
myGLCD.drawRoundRect(x, y, x2, y2);
}
delay(2000);
myGLCD.setColor(0,0,0);
myGLCD.fillRect(1,15,398,224);
for (int i=0; i<100; i++)
{
myGLCD.setColor(random(255), random(255), random(255));
x=2+random(396);
y=16+random(209);
x2=2+random(396);
y2=16+random(209);
myGLCD.drawLine(x, y, x2, y2);
}
delay(2000);
myGLCD.setColor(0,0,0);
myGLCD.fillRect(1,15,398,224);
for (int i=0; i<10000; i++)
{
myGLCD.setColor(random(255), random(255), random(255));
myGLCD.drawPixel(2+random(396), 16+random(209));
}
delay(2000);
myGLCD.fillScr(0, 0, 255);
myGLCD.setColor(255, 0, 0);
myGLCD.fillRoundRect(120, 70, 279, 169);
myGLCD.setColor(255, 255, 255);
myGLCD.setBackColor(255, 0, 0);
myGLCD.print("That's it!", CENTER, 93);
myGLCD.print("Restarting in a", CENTER, 119);
myGLCD.print("few seconds...", CENTER, 132);
myGLCD.setColor(0, 255, 0);
myGLCD.setBackColor(0, 0, 255);
myGLCD.print("Runtime: (msecs)", CENTER, 210);
myGLCD.printNumI(millis(), CENTER, 225);
delay (10000);
}
libraries/MCUFRIEND_kbv/examples/GLUE_Demo_480x320/GLUE_Demo_480x320.ino
+341
View File
@@ -0,0 +1,341 @@
// UTFT_Demo_480x320
// Copyright (C)2015 Rinky-Dink Electronics, Henning Karlsen. All right reserved
// web: http://www.RinkyDinkElectronics.com/
//
// This program is a demo of how to use most of the functions
// of the library with a supported display modules.
//
// This demo was made for modules with a screen resolution
// of 480x320 pixels.
//
// This program requires the UTFT library.
//
//################################################
// GLUE class that implements the UTFT API
// replace UTFT include and constructor statements
// remove UTFT font declaration e.g. SmallFont
//################################################
#include <UTFTGLUE.h> //use GLUE class and constructor
UTFTGLUE myGLCD(0,A2,A1,A3,A4,A0); //all dummy args
// Declare which fonts we will be using
//extern uint8_t SmallFont[]; //GLUE defines as GFXFont ref
// Set the pins to the correct ones for your development shield
// ------------------------------------------------------------
// Arduino Uno / 2009:
// -------------------
// Standard Arduino Uno/2009 shield : <display model>,A5,A4,A3,A2
// DisplayModule Arduino Uno TFT shield : <display model>,A5,A4,A3,A2
//
// Arduino Mega:
// -------------------
// Standard Arduino Mega/Due shield : <display model>,38,39,40,41
// CTE TFT LCD/SD Shield for Arduino Mega : <display model>,38,39,40,41
//
// Remember to change the model parameter to suit your display module!
//UTFT myGLCD(CTE32HR,38,39,40,41);
void setup()
{
randomSeed(analogRead(0));
// Setup the LCD
myGLCD.InitLCD();
myGLCD.setFont(SmallFont);
}
void loop()
{
int buf[478];
int x, x2;
int y, y2;
int r;
// Clear the screen and draw the frame
myGLCD.clrScr();
myGLCD.setColor(255, 0, 0);
myGLCD.fillRect(0, 0, 479, 13);
myGLCD.setColor(64, 64, 64);
myGLCD.fillRect(0, 306, 479, 319);
myGLCD.setColor(255, 255, 255);
myGLCD.setBackColor(255, 0, 0);
myGLCD.print("* Universal Color TFT Display Library *", CENTER, 1);
myGLCD.setBackColor(64, 64, 64);
myGLCD.setColor(255,255,0);
myGLCD.print("<http://www.RinkyDinkElectronics.com/>", CENTER, 307);
myGLCD.setColor(0, 0, 255);
myGLCD.drawRect(0, 14, 479, 305);
// Draw crosshairs
myGLCD.setColor(0, 0, 255);
myGLCD.setBackColor(0, 0, 0);
myGLCD.drawLine(239, 15, 239, 304);
myGLCD.drawLine(1, 159, 478, 159);
for (int i=9; i<470; i+=10)
myGLCD.drawLine(i, 157, i, 161);
for (int i=19; i<220; i+=10)
myGLCD.drawLine(237, i, 241, i);
// Draw sin-, cos- and tan-lines
myGLCD.setColor(0,255,255);
myGLCD.print("Sin", 5, 15);
for (int i=1; i<478; i++)
{
myGLCD.drawPixel(i,159+(sin(((i*1.13)*3.14)/180)*95));
}
myGLCD.setColor(255,0,0);
myGLCD.print("Cos", 5, 27);
for (int i=1; i<478; i++)
{
myGLCD.drawPixel(i,159+(cos(((i*1.13)*3.14)/180)*95));
}
myGLCD.setColor(255,255,0);
myGLCD.print("Tan", 5, 39);
for (int i=1; i<478; i++)
{
myGLCD.drawPixel(i,159+(tan(((i*1.13)*3.14)/180)));
}
delay(2000);
myGLCD.setColor(0,0,0);
myGLCD.fillRect(1,15,478,304);
myGLCD.setColor(0, 0, 255);
myGLCD.setBackColor(0, 0, 0);
myGLCD.drawLine(239, 15, 239, 304);
myGLCD.drawLine(1, 159, 478, 159);
// Draw a moving sinewave
x=1;
for (int i=1; i<(478*15); i++)
{
x++;
if (x==479)
x=1;
if (i>479)
{
if ((x==239)||(buf[x-1]==159))
myGLCD.setColor(0,0,255);
else
myGLCD.setColor(0,0,0);
myGLCD.drawPixel(x,buf[x-1]);
}
myGLCD.setColor(0,255,255);
y=159+(sin(((i*0.7)*3.14)/180)*(90-(i / 100)));
myGLCD.drawPixel(x,y);
buf[x-1]=y;
}
delay(2000);
myGLCD.setColor(0,0,0);
myGLCD.fillRect(1,15,478,304);
// Draw some filled rectangles
for (int i=1; i<6; i++)
{
switch (i)
{
case 1:
myGLCD.setColor(255,0,255);
break;
case 2:
myGLCD.setColor(255,0,0);
break;
case 3:
myGLCD.setColor(0,255,0);
break;
case 4:
myGLCD.setColor(0,0,255);
break;
case 5:
myGLCD.setColor(255,255,0);
break;
}
myGLCD.fillRect(150+(i*20), 70+(i*20), 210+(i*20), 130+(i*20));
}
delay(2000);
myGLCD.setColor(0,0,0);
myGLCD.fillRect(1,15,478,304);
// Draw some filled, rounded rectangles
for (int i=1; i<6; i++)
{
switch (i)
{
case 1:
myGLCD.setColor(255,0,255);
break;
case 2:
myGLCD.setColor(255,0,0);
break;
case 3:
myGLCD.setColor(0,255,0);
break;
case 4:
myGLCD.setColor(0,0,255);
break;
case 5:
myGLCD.setColor(255,255,0);
break;
}
myGLCD.fillRoundRect(270-(i*20), 70+(i*20), 330-(i*20), 130+(i*20));
}
delay(2000);
myGLCD.setColor(0,0,0);
myGLCD.fillRect(1,15,478,304);
// Draw some filled circles
for (int i=1; i<6; i++)
{
switch (i)
{
case 1:
myGLCD.setColor(255,0,255);
break;
case 2:
myGLCD.setColor(255,0,0);
break;
case 3:
myGLCD.setColor(0,255,0);
break;
case 4:
myGLCD.setColor(0,0,255);
break;
case 5:
myGLCD.setColor(255,255,0);
break;
}
myGLCD.fillCircle(180+(i*20),100+(i*20), 30);
}
delay(2000);
myGLCD.setColor(0,0,0);
myGLCD.fillRect(1,15,478,304);
// Draw some lines in a pattern
myGLCD.setColor (255,0,0);
for (int i=15; i<304; i+=5)
{
myGLCD.drawLine(1, i, (i*1.6)-10, 304);
}
myGLCD.setColor (255,0,0);
for (int i=304; i>15; i-=5)
{
myGLCD.drawLine(478, i, (i*1.6)-11, 15);
}
myGLCD.setColor (0,255,255);
for (int i=304; i>15; i-=5)
{
myGLCD.drawLine(1, i, 491-(i*1.6), 15);
}
myGLCD.setColor (0,255,255);
for (int i=15; i<304; i+=5)
{
myGLCD.drawLine(478, i, 490-(i*1.6), 304);
}
delay(2000);
myGLCD.setColor(0,0,0);
myGLCD.fillRect(1,15,478,304);
// Draw some random circles
for (int i=0; i<100; i++)
{
myGLCD.setColor(random(255), random(255), random(255));
x=32+random(416);
y=45+random(226);
r=random(30);
myGLCD.drawCircle(x, y, r);
}
delay(2000);
myGLCD.setColor(0,0,0);
myGLCD.fillRect(1,15,478,304);
// Draw some random rectangles
for (int i=0; i<100; i++)
{
myGLCD.setColor(random(255), random(255), random(255));
x=2+random(476);
y=16+random(289);
x2=2+random(476);
y2=16+random(289);
myGLCD.drawRect(x, y, x2, y2);
}
delay(2000);
myGLCD.setColor(0,0,0);
myGLCD.fillRect(1,15,478,304);
// Draw some random rounded rectangles
for (int i=0; i<100; i++)
{
myGLCD.setColor(random(255), random(255), random(255));
x=2+random(476);
y=16+random(289);
x2=2+random(476);
y2=16+random(289);
myGLCD.drawRoundRect(x, y, x2, y2);
}
delay(2000);
myGLCD.setColor(0,0,0);
myGLCD.fillRect(1,15,478,304);
for (int i=0; i<100; i++)
{
myGLCD.setColor(random(255), random(255), random(255));
x=2+random(476);
y=16+random(289);
x2=2+random(476);
y2=16+random(289);
myGLCD.drawLine(x, y, x2, y2);
}
delay(2000);
myGLCD.setColor(0,0,0);
myGLCD.fillRect(1,15,478,304);
for (int i=0; i<10000; i++)
{
myGLCD.setColor(random(255), random(255), random(255));
myGLCD.drawPixel(2+random(476), 16+random(289));
}
delay(2000);
myGLCD.fillScr(0, 0, 255);
myGLCD.setColor(255, 0, 0);
myGLCD.fillRoundRect(160, 70, 319, 169);
myGLCD.setColor(255, 255, 255);
myGLCD.setBackColor(255, 0, 0);
myGLCD.print("That's it!", CENTER, 93);
myGLCD.print("Restarting in a", CENTER, 119);
myGLCD.print("few seconds...", CENTER, 132);
myGLCD.setColor(0, 255, 0);
myGLCD.setBackColor(0, 0, 255);
myGLCD.print("Runtime: (msecs)", CENTER, 290);
myGLCD.printNumI(millis(), CENTER, 305);
delay (10000);
}
libraries/MCUFRIEND_kbv/examples/GLUE_Demo_800x480/GLUE_Demo_800x480.ino
+296
View File
@@ -0,0 +1,296 @@
// UTFT_Demo_800x480
// Copyright (C)2015 Rinky-Dink Electronics, Henning Karlsen. All right reserved
// web: http://www.RinkyDinkElectronics.com/
//
// This program is a demo of how to use most of the functions
// of the library with a supported display modules.
//
// This demo was made for modules with a screen resolution
// of 800x480 pixels.
//
// This program requires the UTFT library.
//
#include <Adafruit_GFX.h>
#include <UTFTGLUE.h>
UTFTGLUE myGLCD(0x9163,A2,A1,A3,A4,A0); //arguments are ignored
// Declare which fonts we will be using
extern uint8_t SmallFont[];
// Set the pins to the correct ones for your development shield
// ------------------------------------------------------------
// Arduino Uno / 2009:
// -------------------
// Standard Arduino Uno/2009 shield : <display model>,A5,A4,A3,A2
// DisplayModule Arduino Uno TFT shield : <display model>,A5,A4,A3,A2
//
// Arduino Mega:
// -------------------
// Standard Arduino Mega/Due shield : <display model>,38,39,40,41
// CTE TFT LCD/SD Shield for Arduino Mega : <display model>,38,39,40,41
//
// Remember to change the model parameter to suit your display module!
//UTFT myGLCD(ITDB50,38,39,40,41);
void setup()
{
randomSeed(analogRead(0));
// Setup the LCD
myGLCD.InitLCD(PORTRAIT); //800x480 is already wider than tall.
myGLCD.setFont(SmallFont);
}
void loop()
{
int buf[798];
int x, x2;
int y, y2;
int r;
// Clear the screen and draw the frame
myGLCD.clrScr();
myGLCD.setColor(255, 0, 0);
myGLCD.fillRect(0, 0, 799, 13);
myGLCD.setColor(64, 64, 64);
myGLCD.fillRect(0, 466, 799, 479);
myGLCD.setColor(255, 255, 255);
myGLCD.setBackColor(255, 0, 0);
myGLCD.print("* Universal Color TFT Display Library *", CENTER, 1);
myGLCD.setBackColor(64, 64, 64);
myGLCD.setColor(255,255,0);
myGLCD.print("<http://www.RinkyDinkElectronics.com/>", CENTER, 467);
myGLCD.setColor(0, 0, 255);
myGLCD.drawRect(0, 14, 799, 465);
// Draw crosshairs
myGLCD.setColor(0, 0, 255);
myGLCD.setBackColor(0, 0, 0);
myGLCD.drawLine(399, 15, 399, 464);
myGLCD.drawLine(1, 239, 798, 239);
for (int i=9; i<790; i+=10)
myGLCD.drawLine(i, 237, i, 242);
for (int i=19; i<470; i+=10)
myGLCD.drawLine(397, i, 402, i);
// Draw sin-, cos- and tan-lines
myGLCD.setColor(0,255,255);
myGLCD.print("Sin", 5, 15);
for (int i=1; i<798; i++)
{
myGLCD.drawPixel(i,239+(sin(((i*1.13)*3.14)/180)*200));
}
myGLCD.setColor(255,0,0);
myGLCD.print("Cos", 5, 27);
for (int i=1; i<798; i++)
{
myGLCD.drawPixel(i,239+(cos(((i*1.13)*3.14)/180)*200));
}
myGLCD.setColor(255,255,0);
myGLCD.print("Tan", 5, 39);
for (int i=1; i<798; i++)
{
myGLCD.drawPixel(i,239+(tan(((i*0.9)*3.14)/180)));
}
delay(2000);
myGLCD.setColor(0,0,0);
myGLCD.fillRect(1,15,798,464);
myGLCD.setColor(0, 0, 255);
myGLCD.setBackColor(0, 0, 0);
myGLCD.drawLine(399, 15, 399, 464);
myGLCD.drawLine(1, 239, 798, 239);
// Draw a moving sinewave
x=1;
for (int i=1; i<(798*20); i++)
{
x++;
if (x==799)
x=1;
if (i>799)
{
if ((x==399)||(buf[x-1]==239))
myGLCD.setColor(0,0,255);
else
myGLCD.setColor(0,0,0);
myGLCD.drawPixel(x,buf[x-1]);
}
myGLCD.setColor(0,255,255);
y=239+(sin(((i*1.65)*3.14)/180)*(200-(i / 100)));
myGLCD.drawPixel(x,y);
buf[x-1]=y;
}
delay(2000);
myGLCD.setColor(0,0,0);
myGLCD.fillRect(1,15,798,464);
// Draw some random filled rectangles
for (int i=0; i<50; i++)
{
myGLCD.setColor(random(255), random(255), random(255));
x=2+random(746);
y=16+random(397);
x2=x+50;
y2=y+50;
myGLCD.fillRect(x, y, x2, y2);
}
delay(2000);
myGLCD.setColor(0,0,0);
myGLCD.fillRect(1,15,798,464);
// Draw some random filled, rounded rectangles
for (int i=0; i<50; i++)
{
myGLCD.setColor(random(255), random(255), random(255));
x=2+random(746);
y=16+random(397);
x2=x+50;
y2=y+50;
myGLCD.fillRoundRect(x, y, x2, y2);
}
delay(2000);
myGLCD.setColor(0,0,0);
myGLCD.fillRect(1,15,798,464);
// Draw some random filled circles
for (int i=0; i<50; i++)
{
myGLCD.setColor(random(255), random(255), random(255));
x=27+random(746);
y=41+random(397);
myGLCD.fillCircle(x, y, 25);
}
delay(2000);
myGLCD.setColor(0,0,0);
myGLCD.fillRect(1,15,798,464);
// Draw some lines in a pattern
myGLCD.setColor (255,0,0);
for (int i=15; i<463; i+=5)
{
myGLCD.drawLine(1, i, (i*1.66)-10, 463);
}
myGLCD.setColor (255,0,0);
for (int i=463; i>15; i-=5)
{
myGLCD.drawLine(798, i, (i*1.66)+30, 15);
}
myGLCD.setColor (0,255,255);
for (int i=463; i>15; i-=5)
{
myGLCD.drawLine(1, i, 770-(i*1.66), 15);
}
myGLCD.setColor (0,255,255);
for (int i=15; i<463; i+=5)
{
myGLCD.drawLine(798, i, 810-(i*1.66), 463);
}
delay(2000);
myGLCD.setColor(0,0,0);
myGLCD.fillRect(1,15,798,464);
// Draw some random circles
for (int i=0; i<250; i++)
{
myGLCD.setColor(random(255), random(255), random(255));
x=32+random(736);
y=45+random(386);
r=random(30);
myGLCD.drawCircle(x, y, r);
}
delay(2000);
myGLCD.setColor(0,0,0);
myGLCD.fillRect(1,15,798,464);
// Draw some random rectangles
for (int i=0; i<250; i++)
{
myGLCD.setColor(random(255), random(255), random(255));
x=2+random(796);
y=16+random(447);
x2=2+random(796);
y2=16+random(447);
myGLCD.drawRect(x, y, x2, y2);
}
delay(2000);
myGLCD.setColor(0,0,0);
myGLCD.fillRect(1,15,798,464);
// Draw some random rounded rectangles
for (int i=0; i<250; i++)
{
myGLCD.setColor(random(255), random(255), random(255));
x=2+random(796);
y=16+random(447);
x2=2+random(796);
y2=16+random(447);
myGLCD.drawRoundRect(x, y, x2, y2);
}
delay(2000);
myGLCD.setColor(0,0,0);
myGLCD.fillRect(1,15,798,464);
for (int i=0; i<250; i++)
{
myGLCD.setColor(random(255), random(255), random(255));
x=2+random(796);
y=16+random(447);
x2=2+random(796);
y2=16+random(447);
myGLCD.drawLine(x, y, x2, y2);
}
delay(2000);
myGLCD.setColor(0,0,0);
myGLCD.fillRect(1,15,798,464);
for (int i=0; i<10000; i++)
{
myGLCD.setColor(random(255), random(255), random(255));
myGLCD.drawPixel(2+random(796), 16+random(447));
}
delay(2000);
myGLCD.fillScr(0, 0, 255);
myGLCD.setColor(255, 0, 0);
myGLCD.fillRoundRect(320, 190, 479, 289);
myGLCD.setColor(255, 255, 255);
myGLCD.setBackColor(255, 0, 0);
myGLCD.print("That's it!", CENTER, 213);
myGLCD.print("Restarting in a", CENTER, 239);
myGLCD.print("few seconds...", CENTER, 252);
myGLCD.setColor(0, 255, 0);
myGLCD.setBackColor(0, 0, 255);
myGLCD.print("Runtime: (msecs)", CENTER, 450);
myGLCD.printNumI(millis(), CENTER, 465);
delay (10000);
}
libraries/MCUFRIEND_kbv/examples/LCD_ID_readnew/LCD_ID_readnew.ino
+766
View File
@@ -0,0 +1,766 @@
// adapted from LCD_ID_Reader from http://misc.ws/lcd_information
// controllers either read as 16-bit or as a sequence of 8-bit values
//-- Arduino UNO or Mega 2560 Plugged as shield
#define LCD_RST A4 //A1
#define LCD_CS A3
#define LCD_RS A2
#define LCD_WR A1
#define LCD_RD A0
#define LCD_D0 8
#define LCD_D1 9
#define LCD_D2 2 //10
#define LCD_D3 3 //11
#define LCD_D4 4
#define LCD_D5 5 //13
#define LCD_D6 6
#define LCD_D7 7
uint8_t unlock_05A1_F0[] = { (0xF0), 2, 0x5A, 0x5A };
uint8_t unlock_05A1_F1[] = { (0xF1), 2, 0x5A, 0x5A };
uint8_t unlock_1520[] = { (0xB0), 2, 0x00, 0x00 };
uint8_t unlock_1526[] = { (0xB0), 2, 0x3F, 0x3F };
uint8_t unlock_3229[] = { (0x0607), 0 }; //intentional 16-bit command
uint8_t unlock_8357[] = { (0xB9), 3, 0xFF, 0x83, 0x57};
uint8_t unlock_5310[] = { (0xED), 2, 0x01, 0xFE};
uint8_t d5310_0_in[] = { (0xEE), 2, 0xDE, 0x21}; //enter CMD3 8bit args
//uint8_t d5310_1[] = { (0x??), 2, 0xDE, 0x21};
uint8_t d5310_1_in[] = { (0xBF), 1, 0xAA}; //enter page#1 16bit args
uint8_t d5310_1_out[] = { (0x00), 1, 0xAA}; //leave page#1 16bit args
uint8_t d1526nvm[] = { (0xE2), 1, 0x3F};
uint8_t *unlock = NULL;
uint8_t *page_N = NULL;
void setup()
{
Serial.begin(9600);
while (!Serial) ;
Serial.println(F("Read Special Registers on MCUFRIEND UNO shield"));
Serial.println(F("controllers either read as single 16-bit"));
Serial.println(F("e.g. the ID is at readReg(0)"));
Serial.println(F("or as a sequence of 8-bit values"));
Serial.println(F("in special locations (first is dummy)"));
Serial.println(F(""));
lcdInit();
lcdReset(); //ensures that controller is in default state
// unlock = unlock_1520;
// unlock = unlock_1526;
// unlock = unlock_3229;
// unlock = unlock_8357;
// unlock = unlock_5310;
// page_N = d5310_1_in;
// unlock = unlock_05A1_F0;
// page_N = unlock_05A1_F1;
// for (uint16_t i = 0x00; i <= 0xFE; i++) readReg(i, 10, "f.k");
read_regs("diagnose any controller");
// read_xxxx("mystery");
// read_5310_P0("NT35310 P0");
// read_5310_P1("NT35310 P1");
// read_61509("R61509 / ILI9326");
// read_61526("R61520 / R61526");
// read_61581("R61581");
// read_8357("HX8357X");
// read_9320("ILI9320");
// read_9327("ILI9327");
// read_9338("ILI9302 / ILI9329 / ILI9338 / ILI9341");
// read_9481("ILI9481 / HX8357-B / R61581");
// read_9486("ILI9486 / 1LI9488");
}
void loop()
{
// put your main code here, to run repeatedly:
}
void printhex(uint8_t val)
{
if (val < 0x10) Serial.print("0");
Serial.print(val, HEX);
}
void readReg(uint16_t reg, uint8_t n, const char *msg)
{
uint8_t val8;
lcdReset();
lcdSetWriteDir();
if (unlock == unlock_3229) pushCommand(0x0607, NULL, 0);
else if (unlock) pushCommand(unlock[0], unlock + 2, unlock[1]);
if (page_N) pushCommand(page_N[0], page_N + 2, page_N[1]);
Serial.print("reg(0x");
printhex(reg >> 8);
printhex(reg);
Serial.print(")");
lcdWriteCommand(reg);
lcdSetReadDir();
while (n--) {
val8 = lcdReadData8();
Serial.print(" ");
printhex(val8);
}
lcdSetWriteDir();
digitalWrite(LCD_CS, HIGH);
Serial.print("\t");
Serial.println(msg);
}
void lcdInit()
{
pinMode(LCD_CS, OUTPUT);
digitalWrite(LCD_CS, HIGH);
pinMode(LCD_RS, OUTPUT);
digitalWrite(LCD_RS, HIGH);
pinMode(LCD_WR, OUTPUT);
digitalWrite(LCD_WR, HIGH);
pinMode(LCD_RD, OUTPUT);
digitalWrite(LCD_RD, HIGH);
pinMode(LCD_RST, OUTPUT);
digitalWrite(LCD_RST, HIGH);
}
void lcdReset()
{
digitalWrite(LCD_RST, LOW);
delay(2);
digitalWrite(LCD_RST, HIGH);
delay(10); //allow controller to re-start
}
void lcdWrite8(uint16_t data)
{
digitalWrite(LCD_D0, data & 1);
digitalWrite(LCD_D1, (data & 2) >> 1);
digitalWrite(LCD_D2, (data & 4) >> 2);
digitalWrite(LCD_D3, (data & 8) >> 3);
digitalWrite(LCD_D4, (data & 16) >> 4);
digitalWrite(LCD_D5, (data & 32) >> 5);
digitalWrite(LCD_D6, (data & 64) >> 6);
digitalWrite(LCD_D7, (data & 128) >> 7);
}
uint16_t lcdRead8()
{
uint16_t result = digitalRead(LCD_D7);
result <<= 1;
result |= digitalRead(LCD_D6);
result <<= 1;
result |= digitalRead(LCD_D5);
result <<= 1;
result |= digitalRead(LCD_D4);
result <<= 1;
result |= digitalRead(LCD_D3);
result <<= 1;
result |= digitalRead(LCD_D2);
result <<= 1;
result |= digitalRead(LCD_D1);
result <<= 1;
result |= digitalRead(LCD_D0);
return result;
}
void lcdSetWriteDir()
{
uint8_t mode = OUTPUT;
pinMode(LCD_D0, mode);
pinMode(LCD_D1, mode);
pinMode(LCD_D2, mode);
pinMode(LCD_D3, mode);
pinMode(LCD_D4, mode);
pinMode(LCD_D5, mode);
pinMode(LCD_D6, mode);
pinMode(LCD_D7, mode);
}
void lcdSetReadDir()
{
uint8_t mode = INPUT;
pinMode(LCD_D0, mode);
pinMode(LCD_D1, mode);
pinMode(LCD_D2, mode);
pinMode(LCD_D3, mode);
pinMode(LCD_D4, mode);
pinMode(LCD_D5, mode);
pinMode(LCD_D6, mode);
pinMode(LCD_D7, mode);
}
void lcdWriteData(uint16_t data)
{
lcdSetWriteDir();
digitalWrite(LCD_CS, LOW);
digitalWrite(LCD_RS, HIGH);
digitalWrite(LCD_RD, HIGH);
digitalWrite(LCD_WR, HIGH);
lcdWrite8(data >> 8);
digitalWrite(LCD_WR, LOW);
delayMicroseconds(10);
digitalWrite(LCD_WR, HIGH);
lcdWrite8(data);
digitalWrite(LCD_WR, LOW);
delayMicroseconds(10);
digitalWrite(LCD_WR, HIGH);
digitalWrite(LCD_CS, HIGH);
}
void lcdWriteCommand(uint16_t command)
{
lcdSetWriteDir();
digitalWrite(LCD_CS, LOW);
digitalWrite(LCD_RS, LOW);
digitalWrite(LCD_RD, HIGH);
digitalWrite(LCD_WR, HIGH);
lcdWrite8(command >> 8);
digitalWrite(LCD_WR, LOW);
delayMicroseconds(10);
digitalWrite(LCD_WR, HIGH);
lcdWrite8(command);
digitalWrite(LCD_WR, LOW);
delayMicroseconds(10);
digitalWrite(LCD_WR, HIGH);
// digitalWrite(LCD_CS, HIGH);
}
uint8_t lcdReadData8()
{
uint8_t result;
lcdSetReadDir();
digitalWrite(LCD_CS, LOW);
digitalWrite(LCD_RS, HIGH);
digitalWrite(LCD_RD, HIGH);
digitalWrite(LCD_WR, HIGH);
digitalWrite(LCD_RD, LOW);
delayMicroseconds(10);
result = lcdRead8();
digitalWrite(LCD_RD, HIGH);
delayMicroseconds(10);
return result;
}
uint16_t lcdReadData16()
{
uint16_t result;
result = lcdReadData8() << 8;
result |= lcdReadData8();
return result;
}
void lcdWriteRegister(uint16_t addr, uint16_t data)
{
lcdWriteCommand(addr);
lcdWriteData(data);
}
void pushCommand(uint16_t command, uint8_t *block, int8_t n)
{
lcdWriteCommand(command);
digitalWrite(LCD_RS, HIGH);
while (n--) {
lcdWrite8(*block++);
digitalWrite(LCD_WR, LOW);
delayMicroseconds(10);
digitalWrite(LCD_WR, HIGH);
}
digitalWrite(LCD_CS, HIGH);
}
// make all the functions static.
// the linker will discard unused anonymous strings.
static void read_regs(char *title)
{
Serial.println(title);
readReg(0x00, 2, "ID: ILI9320, ILI9325, ILI9335, ...");
readReg(0x04, 4, "Manufacturer ID");
readReg(0x09, 5, "Status Register");
readReg(0x0A, 2, "Get Power Mode");
readReg(0x0C, 2, "Get Pixel Format");
readReg(0x30, 5, "PTLAR");
readReg(0x33, 7, "VSCRLDEF");
readReg(0x61, 2, "RDID1 HX8347-G");
readReg(0x62, 2, "RDID2 HX8347-G");
readReg(0x63, 2, "RDID3 HX8347-G");
readReg(0x64, 2, "RDID1 HX8347-A");
readReg(0x65, 2, "RDID2 HX8347-A");
readReg(0x66, 2, "RDID3 HX8347-A");
readReg(0x67, 2, "RDID Himax HX8347-A");
readReg(0x70, 2, "Panel Himax HX8347-A");
readReg(0xA1, 5, "RD_DDB SSD1963");
readReg(0xB0, 2, "RGB Interface Signal Control");
readReg(0xB3, 5, "Frame Memory");
readReg(0xB4, 2, "Frame Mode");
readReg(0xB6, 5, "Display Control");
readReg(0xB7, 2, "Entry Mode Set");
readReg(0xBF, 6, "ILI9481, HX8357-B");
readReg(0xC0, 9, "Panel Control");
readReg(0xC1, 4, "Display Timing");
readReg(0xC5, 2, "Frame Rate");
readReg(0xC8, 13, "GAMMA");
readReg(0xCC, 2, "Panel Control");
readReg(0xD0, 4, "Power Control");
readReg(0xD1, 4, "VCOM Control");
readReg(0xD2, 3, "Power Normal");
readReg(0xD3, 4, "ILI9341, ILI9488");
readReg(0xD4, 4, "Novatek");
readReg(0xDA, 2, "RDID1");
readReg(0xDB, 2, "RDID2");
readReg(0xDC, 2, "RDID3");
readReg(0xE0, 16, "GAMMA-P");
readReg(0xE1, 16, "GAMMA-N");
readReg(0xEF, 6, "ILI9327");
readReg(0xF2, 12, "Adjust Control 2");
readReg(0xF6, 4, "Interface Control");
}
static void read_5310_P0(char *title)
{
Serial.println(title);
readReg(0xB0, 2, "DISPLAY_CTRL");
readReg(0xB1, 4, "PORCH_CTRL");
readReg(0xB2, 4, "FRAME_CTRL");
readReg(0xB3, 2, "SPI_RGB");
readReg(0xB6, 7, "SOURCE_EQ");
readReg(0xC0, 5, "PWR_CTRL1");
readReg(0xC1, 3, "PWR_CTRL2");
readReg(0xC2, 4, "PWR_CTRL3");
readReg(0xC3, 2, "PWR_CTRL5");
readReg(0xC4, 2, "PWR_CTRL6");
readReg(0xC5, 5, "PWR_CTRL7");
readReg(0xC6, 5, "PWR_CTRL8");
readReg(0xD1, 2, "WRID");
readReg(0xD2, 2, "WRID");
readReg(0xD3, 2, "WRID");
readReg(0xD4, 5, "RDID4");
readReg(0xD5, 5, "WRDDB");
readReg(0xDE, 4, "EPWR");
readReg(0xFF, 2, "PAGE_STATUS");
}
static void read_5310_P1(char *title)
{
Serial.println(title);
/*
readReg(0xB0, 19, "f.k");
readReg(0xB1, 7, "f.k");
readReg(0xB2, 7, "f.k");
readReg(0xB3, 25, "f.k");
readReg(0xB4, 7, "f.k");
readReg(0xB5, 7, "f.k");
readReg(0xB6, 3, "f.k");
readReg(0xB7, 23, "f.k");
readReg(0xB8, 7, "f.k");
readReg(0xBA, 5, "f.k");
readReg(0xC0, 19, "f.k");
readReg(0xC1, 7, "f.k");
readReg(0xC2, 5, "f.k");
readReg(0xC3, 49, "f.k");
readReg(0xC4, 27, "f.k");
readReg(0xC5, 11, "f.k");
readReg(0xC6, 7, "f.k");
readReg(0xC7, 5, "f.k");
readReg(0xC8, 5, "f.k");
readReg(0xC9, 17, "f.k");
*/
readReg(0xE0, 37, "GAMMA_RED_P");
readReg(0xE1, 37, "GAMMA_RED_N");
readReg(0xE2, 37, "GAMMA_GREEN_P");
readReg(0xE3, 37, "GAMMA_GREEN_N");
readReg(0xE4, 37, "GAMMA_BLUE_P");
readReg(0xE5, 37, "GAMMA_BLUE_N");
readReg(0xE6, 33, "CABC_RED");
readReg(0xE7, 33, "CABC_GREEN");
readReg(0xE8, 33, "CABC_BLUE");
// readReg(0xE9, 5, "f.k.");
readReg(0xFF, 2, "PAGE_STATUS");
}
static void read_61509(char *title)
{
Serial.println(title);
readReg(0x0000, 2, "Device Code Read");
readReg(0x0001, 2, "Device Output Control");
readReg(0x0002, 2, "LCD Waveform Control");
readReg(0x0003, 2, "Entry Mode");
readReg(0x0007, 2, "Display Control 1");
readReg(0x0008, 2, "Display Control 2");
readReg(0x0009, 2, "Display Control 3");
readReg(0x0010, 2, "Panel Interface Control 1");
readReg(0x0011, 2, "Panel Interface Control 2");
readReg(0x0012, 2, "Panel Interface Control 3");
readReg(0x0013, 2, "Panel Interface Control 4");
readReg(0x0100, 2, "Power Control 1");
readReg(0x0101, 2, "Power Control 2");
readReg(0x0102, 2, "Power Control 3");
readReg(0x0103, 2, "Power Control 4");
readReg(0x0210, 2, "Horiz SA");
readReg(0x0211, 2, "Horiz EA");
readReg(0x0212, 2, "Vert SA");
readReg(0x0213, 2, "Vert EA");
readReg(0x0400, 2, "Base Image NL");
readReg(0x0401, 2, "Base Image Control");
readReg(0x0404, 2, "Base Image Scroll");
}
static void read_61526(char *title)
{
Serial.println(title);
readReg(0x04, 4, "Manufacturer ID");
readReg(0x0A, 2, "Get Power Mode");
readReg(0x0B, 2, "Get Address Mode");
readReg(0x0C, 2, "Get Pixel Format");
readReg(0x0D, 2, "Get Display Mode");
readReg(0x0E, 2, "Get Signal Mode");
readReg(0x0F, 2, "Get Diagnostic Result");
readReg(0xA1, 6, "RD_DDB Start");
readReg(0xB0, 3, "Command Access Protect");
readReg(0xB3, 6, "Frame Memory");
readReg(0xB4, 2, "Frame Mode");
readReg(0xBF, 5, "Device Code Read");
readReg(0xC0, 9, "Panel Control");
readReg(0xC1, 6, "Display Timing Normal");
readReg(0xC3, 6, "Display Timing Idle");
readReg(0xC4, 6, "Timing setting");
readReg(0xC8, 23, "GAMMA");
readReg(0xC9, 23, "GAMMA");
readReg(0xCA, 23, "GAMMA");
readReg(0xD0, 7, "Power Control");
readReg(0xD1, 4, "VCOM Control");
readReg(0xD2, 3, "Power Normal");
readReg(0xD4, 3, "Power Idle");
readReg(0xE0, 4, "NVM Access");
readReg(0xE1, 2, "set_DDB");
readReg(0xE2, 2, "NVM Load Control");
}
static void read_8357(char *title)
{
Serial.println(title);
readReg(0x0A, 2, "Get Power Mode");
readReg(0x0B, 2, "Get Address Mode");
readReg(0x0C, 2, "Get Pixel Format");
readReg(0x0D, 2, "Get Display Mode");
readReg(0x0E, 2, "Get Signal Mode");
readReg(0x0F, 2, "Get Diagnostic Result");
readReg(0xA1, 6, "RD_DDB Start");
readReg(0xB0, 3, "SETOSC");
readReg(0xB1, 8, "SETPOWER");
readReg(0xB2, 6, "SETDISPLAY");
readReg(0xB3, 5, "SETRGB");
readReg(0xB4, 8, "SETCYC");
readReg(0xB5, 4, "SETBGP");
readReg(0xB6, 3, "SETVCOM");
readReg(0xB7, 6, "SETOTP");
readReg(0xB9, 4, "SETEXTC");
readReg(0xC0, 7, "SETSTBA");
readReg(0xC1, 11, "SETDGC");
readReg(0xC3, 5, "SETID");
readReg(0xC4, 5, "SETDDB");
readReg(0xC9, 3, "SETCABC");
readReg(0xCC, 2, "SETPANEL");
readReg(0xD0, 4, "GETICID");
readReg(0xE0, 35, "SETGAMMA");
readReg(0xE9, 2, "SETIMAGEI");
readReg(0xEA, 2, "SETMESSI");
}
static void read_fk(char *title)
{
Serial.println(title);
readReg(0x0A, 2, "Get Power Mode");
readReg(0x0B, 2, "Get Address Mode");
readReg(0x0C, 2, "Get Pixel Format");
readReg(0x0D, 2, "Get Display Mode");
readReg(0x0E, 2, "Get Signal Mode");
readReg(0x0F, 2, "Get Diagnostic Result");
readReg(0xA1, 6, "RD_DDB Start");
readReg(0xB0, 3, "Command Access Protect");
readReg(0xBF, 5, "Device Code Read");
readReg(0xF0, 4, "f.k.");
readReg(0xF2, 18, "f.k.");
readReg(0xF3, 2, "f.k.");
readReg(0xF4, 14, "f.k.");
readReg(0xF5, 11, "f.k.");
readReg(0xF6, 10, "f.k.");
readReg(0xF7, 4, "f.k.");
readReg(0xF8, 2, "f.k.");
readReg(0xF9, 2, "f.k.");
readReg(0xFA, 12, "f.k.");
readReg(0xFB, 2, "f.k.");
readReg(0xFC, 2, "f.k.");
readReg(0xFD, 12, "f.k.");
readReg(0xFE, 2, "f.k.");
}
static void read_xxxx(char *title)
{
Serial.println(title);
readReg(0x09, 5, "Status Register");
readReg(0x0A, 2, "Get Power Mode");
readReg(0x0B, 2, "Get Address Mode");
readReg(0x0C, 2, "Get Pixel Format");
readReg(0x0D, 2, "Get Display Mode");
readReg(0x0E, 2, "Get Signal Mode");
readReg(0x0F, 2, "Get Diagnostic Result");
readReg(0xA1, 6, "RD_DDB Start");
readReg(0xB0, 3, "Command Access Protect");
readReg(0xBF, 5, "Device Code Read");
readReg(0xC6, 2, "f.k.");
readReg(0xD6, 4, "f.k.");
readReg(0xD7, 5, "f.k.");
readReg(0xD8, 5, "f.k.");
readReg(0xD9, 4, "f.k.");
readReg(0xE0, 2, "f.k.");
readReg(0xE1, 3, "f.k.");
readReg(0xF0, 2, "f.k.");
readReg(0xF1, 2, "f.k.");
readReg(0xF2, 12, "f.k.");
readReg(0xF3, 9, "f.k.");
readReg(0xF4, 6, "f.k.");
readReg(0xF5, 7, "f.k.");
readReg(0xF6, 5, "f.k.");
readReg(0xF7, 16, "f.k.");
readReg(0xFD, 4, "f.k.");
readReg(0xFE, 2, "f.k.");
readReg(0xFF, 2, "f.k.");
}
static void read_9320(char *title)
{
Serial.println(title);
readReg(0x0000, 2, "Device Code Read");
readReg(0x0001, 2, "Drive Output Control");
readReg(0x0002, 2, "LCD Waveform Control");
readReg(0x0003, 2, "Entry Mode");
readReg(0x0007, 2, "Display Control 1");
readReg(0x0008, 2, "Display Control 2");
readReg(0x0009, 2, "Display Control 3");
readReg(0x000A, 2, "Display Control 4");
readReg(0x0010, 2, "Power Control 1");
readReg(0x0011, 2, "Power Control 2");
readReg(0x0012, 2, "Power Control 3");
readReg(0x0013, 2, "Power Control 4");
readReg(0x0014, 2, "Power Control 5");
readReg(0x0015, 2, "Power Control 6");
readReg(0x0029, 2, "Power Control 7");
readReg(0x002B, 2, "Frame Rate");
}
static void read_9327(char *title)
{
Serial.println(title);
readReg(0x0A, 2, "Get Power Mode");
readReg(0x0B, 2, "Get Address Mode");
readReg(0x0C, 2, "Get Pixel Format");
readReg(0x0D, 2, "Get Display Mode");
readReg(0x0E, 2, "Get Signal Mode");
readReg(0x0F, 2, "Get Diagnostic Result");
readReg(0xA1, 6, "RD_DDB Start");
readReg(0xB0, 2, "Command Access Protect");
readReg(0xB1, 2, "Low Power Control");
readReg(0xB3, 5, "Frame Memory");
readReg(0xB4, 2, "Frame Mode");
readReg(0xB5, 2, "Sub Panel Control");
readReg(0xBF, 2, "Backlight Control");
readReg(0xC0, 7, "Panel Control");
readReg(0xC1, 4, "Display Timing Normal");
readReg(0xC3, 4, "Display Timing Idle");
readReg(0xC4, 2, "VCOM Timing");
readReg(0xC5, 2, "Frame Rate");
readReg(0xC6, 2, "Interface Control");
readReg(0xC8, 13, "GAMMA");
readReg(0xC9, 13, "GAMMA Red/Blue");
readReg(0xCC, 2, "Panel Control");
readReg(0xD0, 4, "Power Control");
readReg(0xD1, 4, "VCOM Control");
readReg(0xD2, 3, "Power Normal");
readReg(0xD3, 3, "Power Partial");
readReg(0xD4, 3, "Power Idle");
readReg(0xEF, 6, "Device Code Read");
}
static void read_9338(char *title)
{
Serial.println(title);
readReg(0x04, 4, "Manufacturer ID");
// readReg(0x05, 2, "DSI errors");
readReg(0x09, 5, "Status Register");
readReg(0x0A, 2, "Get Power Mode");
readReg(0x0B, 2, "Get Address Mode");
readReg(0x0C, 2, "Get Pixel Format");
readReg(0x0D, 2, "Get Display Mode");
readReg(0x0E, 2, "Get Signal Mode");
readReg(0x0F, 2, "Get Diagnostic Result");
readReg(0xB0, 2, "Interface Mode");
readReg(0xB1, 3, "Frame Rate Normal");
readReg(0xB2, 3, "Frame Rate Idle");
readReg(0xB3, 3, "Frame Rate Partial");
readReg(0xB4, 3, "Inversion Control");
readReg(0xB5, 5, "Blanking Porch");
readReg(0xB6, 4, "Display Control");
readReg(0xB7, 2, "Entry Mode Set");
readReg(0xC0, 2, "Power Control 1");
readReg(0xC1, 2, "Power Control 2");
readReg(0xC2, 2, "Power Control 3");
readReg(0xC3, 2, "Power Control 4");
readReg(0xC4, 2, "Power Control 5");
readReg(0xC5, 3, "VCOM Control 1");
readReg(0xC7, 2, "VCOM Control 2");
/*
readReg(0xD0, 3, "NVM Write");
readReg(0xD1, 4, "NVM key");
*/
readReg(0xD2, 3, "NVM Status");
readReg(0xD3, 4, "RDID4");
readReg(0xDA, 2, "RDID1");
readReg(0xDB, 2, "RDID2");
readReg(0xDC, 2, "RDID3");
readReg(0xE0, 16, "GAMMA-P");
readReg(0xE1, 16, "GAMMA-N");
readReg(0xF2, 2, "GAMMA-3G");
readReg(0xF6, 4, "Interface Control");
}
static void read_9481(char *title)
{
Serial.println(title);
readReg(0x0A, 2, "Get Power Mode");
readReg(0x0B, 2, "Get Address Mode");
readReg(0x0C, 2, "Get Pixel Format");
readReg(0x0D, 2, "Get Display Mode");
readReg(0x0E, 2, "Get Signal Mode");
readReg(0x0F, 2, "Get Diagnostic Result");
readReg(0xA1, 6, "RD_DDB Start");
readReg(0xB0, 2, "Command Access Protect");
readReg(0xB3, 5, "Frame Memory");
readReg(0xB4, 2, "Frame Mode");
readReg(0xBF, 6, "Device Code Read");
readReg(0xC0, 6, "Panel Control");
readReg(0xC1, 4, "Display Timing Normal");
readReg(0xC2, 4, "Display Timing Partial");
readReg(0xC3, 4, "Display Timing Idle");
readReg(0xC5, 2, "Frame Rate");
readReg(0xC6, 2, "Interface Control");
readReg(0xC8, 13, "GAMMA");
readReg(0xCC, 2, "Panel Control");
readReg(0xD0, 4, "Power Control");
readReg(0xD1, 4, "VCOM Control");
readReg(0xD2, 3, "Power Normal");
readReg(0xD3, 3, "Power Partial");
readReg(0xD4, 3, "Power Idle");
readReg(0xE4, 4, "? SETCABC(HX) (f.k. ILI)");
readReg(0xE9, 4, "? Set Panel Related(HX)");
readReg(0xEE, 5, "? Set EQ Function(HX)");
readReg(0xF0, 4, "f.k (ILI)");
readReg(0xF1, 2, "f.k");
readReg(0xF2, 4, "f.k");
readReg(0xF3, 4, "f.k (ILI)");
readReg(0xF4, 4, "f.k");
readReg(0xF5, 2, "f.k");
readReg(0xF6, 2, "f.k");
readReg(0xF7, 4, "f.k");
readReg(0xF8, 3, "f.k");
readReg(0xF9, 2, "f.k");
}
static void read_9486(char *title)
{
Serial.println(title);
readReg(0x04, 4, "Manufacturer ID");
readReg(0x05, 2, "DSI errors");
readReg(0x09, 5, "Status Register");
readReg(0x0A, 2, "Get Power Mode");
readReg(0x0B, 2, "Get Address Mode");
readReg(0x0C, 2, "Get Pixel Format");
readReg(0x0D, 2, "Get Display Mode");
readReg(0x0E, 2, "Get Signal Mode");
readReg(0x0F, 2, "Get Diagnostic Result");
readReg(0xB0, 2, "Interface Mode");
readReg(0xB1, 3, "Frame Rate Normal");
readReg(0xB2, 3, "Frame Rate Idle");
readReg(0xB3, 3, "Frame Rate Partial");
readReg(0xB4, 2, "Inversion Control");
readReg(0xB5, 5, "Blanking Porch");
readReg(0xB6, 4, "Display Control");
readReg(0xB7, 2, "Entry Mode Set");
readReg(0xBF, 6, "NON-Ilitek Device Code Read");
readReg(0xC0, 3, "Power Control 1");
readReg(0xC1, 3, "Power Control 2");
readReg(0xC2, 2, "Power Control 3");
readReg(0xC3, 2, "Power Control 4");
readReg(0xC4, 2, "Power Control 5");
readReg(0xC5, 5, "VCOM Control 1");
/*
readReg(0xC6, 3, "CABC Control 1");
readReg(0xC8, 3, "CABC Control 2");
readReg(0xC9, 2, "CABC Control 3");
readReg(0xCA, 2, "CABC Control 4");
readReg(0xCB, 2, "CABC Control 5");
readReg(0xCC, 2, "CABC Control 6");
readReg(0xCD, 2, "CABC Control 7");
readReg(0xCE, 2, "CABC Control 8");
readReg(0xCF, 2, "CABC Control 9");
readReg(0xD0, 3, "NVM Write");
readReg(0xD1, 4, "NVM key");
readReg(0xD2, 5, "NVM Status");
*/
readReg(0xD3, 4, "RDID4");
readReg(0xDA, 2, "RDID1");
readReg(0xDB, 2, "RDID2");
readReg(0xDC, 2, "RDID3");
readReg(0xE0, 16, "GAMMA-P");
readReg(0xE1, 16, "GAMMA-N");
readReg(0xF2, 10, "Adjust 2");
readReg(0xF7, 5, "Adjust 3");
readReg(0xF8, 3, "Adjust 4");
readReg(0xF9, 3, "Adjust 5");
readReg(0xFB, 2, "SPI Read");
readReg(0xFC, 3, "Adjust 6");
}
static void read_61581(char *title)
{
Serial.println(title);
readReg(0x0A, 2, "Get Power Mode");
readReg(0x0B, 2, "Get Address Mode");
readReg(0x0C, 2, "Get Pixel Format");
readReg(0x0D, 2, "Get Display Mode");
readReg(0x0E, 2, "Get Signal Mode");
readReg(0x0F, 2, "Get Diagnostic Result");
readReg(0xA1, 6, "RD_DDB Start");
readReg(0xB0, 2, "Command Access Protect");
readReg(0xB3, 5, "Frame Memory");
readReg(0xB4, 2, "Frame Mode");
readReg(0xB8, 19, "Backlight ctl1");
readReg(0xB9, 6, "Backlight ctl2");
readReg(0xBA, 2, "Backlight ctl3");
readReg(0xBC, 2, "MDDI CRC");
readReg(0xBF, 5, "Device Code Read");
readReg(0xC0, 9, "Panel Control");
readReg(0xC1, 5, "Display Timing Normal");
readReg(0xC2, 5, "Display Timing Partial");
readReg(0xC3, 5, "Display Timing Idle");
readReg(0xC4, 5, "Gate Drive");
readReg(0xC6, 2, "Interface Control");
readReg(0xC8, 21, "GAMMA");
readReg(0xD0, 4, "Power Control");
readReg(0xD1, 4, "VCOM Control");
readReg(0xD2, 4, "Power Normal");
readReg(0xD3, 4, "Power Partial");
readReg(0xD4, 4, "Power Idle");
}
libraries/MCUFRIEND_kbv/examples/LCD_ID_readreg/LCD_ID_readreg.ino
+266
View File
@@ -0,0 +1,266 @@
// adapted from LCD_ID_Reader from http://misc.ws/lcd_information
// controllers either read as 16-bit or as a sequence of 8-bit values
//-- Arduino UNO or Mega 2560 Plugged as shield
#define LCD_RST A4
#define LCD_CS A3
#define LCD_RS A2
#define LCD_WR A1
#define LCD_RD A0
#define LCD_D0 8
#define LCD_D1 9
#define LCD_D2 2
#define LCD_D3 3
#define LCD_D4 4
#define LCD_D5 5
#define LCD_D6 6
#define LCD_D7 7
void setup()
{
Serial.begin(9600);
while (!Serial) ;
Serial.println("Read Registers on MCUFRIEND UNO shield");
Serial.println("controllers either read as single 16-bit");
Serial.println("e.g. the ID is at readReg(0)");
Serial.println("or as a sequence of 8-bit values");
Serial.println("in special locations (first is dummy)");
Serial.println("");
lcdInit();
lcdReset(); //ensures that controller is in default state
// for (uint16_t i = 0; i < 256; i++) readReg(i, 7, "f.k");
readReg(0x00, 2, "ID: ILI9320, ILI9325, ILI9335, ...");
readReg(0x04, 4, "Manufacturer ID");
readReg(0x09, 5, "Status Register");
readReg(0x0A, 2, "Get Power Mode");
readReg(0x0C, 2, "Get Pixel Format");
readReg(0x61, 2, "RDID1 HX8347-G");
readReg(0x62, 2, "RDID2 HX8347-G");
readReg(0x63, 2, "RDID3 HX8347-G");
readReg(0x64, 2, "RDID1 HX8347-A");
readReg(0x65, 2, "RDID2 HX8347-A");
readReg(0x66, 2, "RDID3 HX8347-A");
readReg(0x67, 2, "RDID Himax HX8347-A");
readReg(0x70, 2, "Panel Himax HX8347-A");
readReg(0xA1, 5, "RD_DDB SSD1963");
readReg(0xB0, 2, "RGB Interface Signal Control");
readReg(0xB4, 2, "Inversion Control");
readReg(0xB6, 5, "Display Control");
readReg(0xB7, 2, "Entry Mode Set");
readReg(0xBF, 6, "ILI9481, HX8357-B");
readReg(0xC0, 9, "Panel Control");
readReg(0xC8, 13, "GAMMA");
readReg(0xCC, 2, "Panel Control");
readReg(0xD0, 3, "Power Control");
readReg(0xD2, 5, "NVM Read");
readReg(0xD3, 4, "ILI9341, ILI9488");
readReg(0xD4, 4, "Novatek ID");
readReg(0xDA, 2, "RDID1");
readReg(0xDB, 2, "RDID2");
readReg(0xDC, 2, "RDID3");
readReg(0xE0, 16, "GAMMA-P");
readReg(0xE1, 16, "GAMMA-N");
readReg(0xEF, 6, "ILI9327");
readReg(0xF2, 12, "Adjust Control 2");
readReg(0xF6, 4, "Interface Control");
}
void loop()
{
// put your main code here, to run repeatedly:
}
void printhex(uint8_t val)
{
if (val < 0x10) Serial.print("0");
Serial.print(val, HEX);
}
void readReg(uint16_t reg, uint8_t n, const char *msg)
{
uint8_t val8;
lcdReset();
lcdSetWriteDir();
lcdWriteCommand(0xB0); //Command Access Protect
lcdWriteData(0x00); //looks wrong
/*
lcdWriteCommand(0xF6);
lcdWriteData(0x01);
lcdWriteData(0x01);
lcdWriteData(0x03);
*/
lcdWriteCommand(reg);
Serial.print("reg(0x");
printhex(reg >> 8);
printhex(reg);
Serial.print(")");
lcdSetReadDir();
while (n--) {
val8 = lcdReadData8();
Serial.print(" ");
printhex(val8);
}
lcdSetWriteDir();
Serial.print("\t");
Serial.println(msg);
}
void lcdInit()
{
pinMode(LCD_CS, OUTPUT);
digitalWrite(LCD_CS, HIGH);
pinMode(LCD_RS, OUTPUT);
digitalWrite(LCD_RS, HIGH);
pinMode(LCD_WR, OUTPUT);
digitalWrite(LCD_WR, HIGH);
pinMode(LCD_RD, OUTPUT);
digitalWrite(LCD_RD, HIGH);
pinMode(LCD_RST, OUTPUT);
digitalWrite(LCD_RST, HIGH);
}
void lcdReset()
{
digitalWrite(LCD_RST, LOW);
delay(2);
digitalWrite(LCD_RST, HIGH);
delay(10); //allow controller to re-start
}
void lcdWrite8(uint16_t data)
{
digitalWrite(LCD_D0, data & 1);
digitalWrite(LCD_D1, (data & 2) >> 1);
digitalWrite(LCD_D2, (data & 4) >> 2);
digitalWrite(LCD_D3, (data & 8) >> 3);
digitalWrite(LCD_D4, (data & 16) >> 4);
digitalWrite(LCD_D5, (data & 32) >> 5);
digitalWrite(LCD_D6, (data & 64) >> 6);
digitalWrite(LCD_D7, (data & 128) >> 7);
}
uint16_t lcdRead8()
{
uint16_t result = digitalRead(LCD_D7);
result <<= 1;
result |= digitalRead(LCD_D6);
result <<= 1;
result |= digitalRead(LCD_D5);
result <<= 1;
result |= digitalRead(LCD_D4);
result <<= 1;
result |= digitalRead(LCD_D3);
result <<= 1;
result |= digitalRead(LCD_D2);
result <<= 1;
result |= digitalRead(LCD_D1);
result <<= 1;
result |= digitalRead(LCD_D0);
return result;
}
void lcdSetWriteDir()
{
pinMode(LCD_D0, OUTPUT);
pinMode(LCD_D1, OUTPUT);
pinMode(LCD_D2, OUTPUT);
pinMode(LCD_D3, OUTPUT);
pinMode(LCD_D4, OUTPUT);
pinMode(LCD_D5, OUTPUT);
pinMode(LCD_D6, OUTPUT);
pinMode(LCD_D7, OUTPUT);
}
void lcdSetReadDir()
{
pinMode(LCD_D0, INPUT);
pinMode(LCD_D1, INPUT);
pinMode(LCD_D2, INPUT);
pinMode(LCD_D3, INPUT);
pinMode(LCD_D4, INPUT);
pinMode(LCD_D5, INPUT);
pinMode(LCD_D6, INPUT);
pinMode(LCD_D7, INPUT);
}
void lcdWriteData(uint16_t data)
{
lcdSetWriteDir();
digitalWrite(LCD_CS, LOW);
digitalWrite(LCD_RS, HIGH);
digitalWrite(LCD_RD, HIGH);
digitalWrite(LCD_WR, HIGH);
lcdWrite8(data >> 8);
digitalWrite(LCD_WR, LOW);
delayMicroseconds(10);
digitalWrite(LCD_WR, HIGH);
lcdWrite8(data);
digitalWrite(LCD_WR, LOW);
delayMicroseconds(10);
digitalWrite(LCD_WR, HIGH);
digitalWrite(LCD_CS, HIGH);
}
void lcdWriteCommand(uint16_t command)
{
lcdSetWriteDir();
digitalWrite(LCD_CS, LOW);
digitalWrite(LCD_RS, LOW);
digitalWrite(LCD_RD, HIGH);
digitalWrite(LCD_WR, HIGH);
lcdWrite8(command >> 8);
digitalWrite(LCD_WR, LOW);
delayMicroseconds(10);
digitalWrite(LCD_WR, HIGH);
lcdWrite8(command);
digitalWrite(LCD_WR, LOW);
delayMicroseconds(10);
digitalWrite(LCD_WR, HIGH);
digitalWrite(LCD_CS, HIGH);
}
uint8_t lcdReadData8()
{
uint8_t result;
lcdSetReadDir();
digitalWrite(LCD_CS, LOW);
digitalWrite(LCD_RS, HIGH);
digitalWrite(LCD_RD, HIGH);
digitalWrite(LCD_WR, HIGH);
digitalWrite(LCD_RD, LOW);
delayMicroseconds(10);
result = lcdRead8();
digitalWrite(LCD_RD, HIGH);
delayMicroseconds(10);
return result;
}
uint16_t lcdReadData16()
{
uint16_t result;
result = lcdReadData8() << 8;
result |= lcdReadData8();
return result;
}
void lcdWriteRegister(uint16_t addr, uint16_t data)
{
lcdWriteCommand(addr);
lcdWriteData(data);
}
libraries/MCUFRIEND_kbv/examples/TouchScreen_Calibr_native/TouchScreen_Calibr_native.ino
+453
View File
@@ -0,0 +1,453 @@
// TouchScreen_Calibr_native for MCUFRIEND UNO Display Shields
// adapted by David Prentice
// for Adafruit's <TouchScreen.h> Resistive Touch Screen Library
// from Henning Karlsen's original UTouch_Calibration program.
// Many Thanks.
#define PORTRAIT 0
#define LANDSCAPE 1
#define USE_XPT2046 0
#define USE_LOCAL_KBV 1
#define TOUCH_ORIENTATION PORTRAIT
#if defined(USB_PID) && USB_PID == 0x804E // Arduino M0 Native
#define Serial SerialUSB
#endif
#define SWAP(x, y) { int t = x; x = y; y = t; }
#define TITLE "TouchScreen.h GFX Calibration"
#include <Adafruit_GFX.h>
#include <MCUFRIEND_kbv.h>
MCUFRIEND_kbv tft;
// MCUFRIEND UNO shield shares pins with the TFT.
#if defined(ESP32)
int XP = 27, YP = 4, XM = 15, YM = 14; //most common configuration
#else
//int XP = 6, YP = A1, XM = A2, YM = 7; //most common configuration
int XP = 7, YP = A2, XM = A1, YM = 6; //next common configuration
//int XP=PB7,XM=PA6,YP=PA7,YM=PB6; //BLUEPILL must have Analog for YP, XM
#endif
#if USE_LOCAL_KBV
#include "TouchScreen_kbv.h" //my hacked version
#define TouchScreen TouchScreen_kbv
#define TSPoint TSPoint_kbv
#else
#include <TouchScreen.h> //Adafruit Library
#endif
TouchScreen ts(XP, YP, XM, YM, 300); //re-initialised after diagnose
TSPoint tp; //global point
void readResistiveTouch(void)
{
tp = ts.getPoint();
pinMode(YP, OUTPUT); //restore shared pins
pinMode(XM, OUTPUT);
//digitalWrite(YP, HIGH); //because TFT control pins
//digitalWrite(XM, HIGH);
// Serial.println("tp.x=" + String(tp.x) + ", tp.y=" + String(tp.y) + ", tp.z =" + String(tp.z));
}
uint16_t readID(void) {
uint16_t ID = tft.readID();
if (ID == 0xD3D3) ID = 0x9486;
return ID;
}
#define TFT_BEGIN() tft.begin(ID)
#define WHITE 0xFFFF
#define RED 0xF800
#define BLUE 0x001F
#define GREEN 0x07E0
#define BLACK 0x0000
//#define GRAY 0x2408 //un-highlighted cross-hair
#define GRAY BLUE //idle cross-hair colour
#define GRAY_DONE RED //finished cross-hair
bool ISPRESSED(void)
{
// .kbv this was too sensitive !!
// now touch has to be stable for 50ms
int count = 0;
bool state, oldstate;
while (count < 10) {
readResistiveTouch();
state = tp.z > 200; //ADJUST THIS VALUE TO SUIT YOUR SCREEN e.g. 20 ... 250
if (state == oldstate) count++;
else count = 0;
oldstate = state;
delay(5);
}
return oldstate;
}
uint32_t cx, cy, cz;
uint32_t rx[8], ry[8];
int32_t clx, crx, cty, cby;
float px, py;
int dispx, dispy, text_y_center, swapxy;
uint32_t calx, caly, cals;
char *Aval(int pin)
{
static char buf[2][10], cnt;
cnt = !cnt;
#if defined(ESP32)
sprintf(buf[cnt], "%d", pin);
#else
sprintf(buf[cnt], "A%d", pin - A0);
#endif
return buf[cnt];
}
void showpins(int A, int D, int value, const char *msg)
{
char buf[40];
sprintf(buf, "%s (%s, D%d) = %d", msg, Aval(A), D, value);
Serial.println(buf);
}
void bofe(char *buf)
{
tft.println(buf);
Serial.println(buf);
}
#if USE_XPT2046 == 0
bool diagnose_pins()
{
uint8_t i, j, Apins[2], Dpins[2], found = 0;
uint16_t value, Values[2];
Serial.println(F("Making all control and bus pins INPUT_PULLUP"));
Serial.println(F("Typical 30k Analog pullup with corresponding pin"));
Serial.println(F("would read low when digital is written LOW"));
Serial.println(F("e.g. reads ~25 for 300R X direction"));
Serial.println(F("e.g. reads ~30 for 500R Y direction"));
Serial.println(F(""));
for (i = A0; i < A5; i++) pinMode(i, INPUT_PULLUP);
for (i = 2; i < 10; i++) pinMode(i, INPUT_PULLUP);
for (i = A0; i < A4; i++) {
pinMode(i, INPUT_PULLUP);
for (j = 5; j < 10; j++) {
pinMode(j, OUTPUT);
digitalWrite(j, LOW);
value = analogRead(i); // ignore first reading
value = analogRead(i);
if (value < 100 && value > 0) {
showpins(i, j, value, "Testing :");
if (found < 2) {
Apins[found] = i;
Dpins[found] = j;
Values[found] = value;
}
found++;
}
pinMode(j, INPUT_PULLUP);
}
pinMode(i, INPUT_PULLUP);
}
if (found == 2) {
int idx = Values[0] < Values[1];
/*
Serial.println(F("Diagnosing as:-"));
for (i = 0; i < 2; i++) {
showpins(Apins[i], Dpins[i], Values[i],
(Values[i] < Values[!i]) ? "XM,XP: " : "YP,YM: ");
}
*/
XM = Apins[!idx]; XP = Dpins[!idx]; YP = Apins[idx]; YM = Dpins[idx];
ts = TouchScreen(XP, YP, XM, YM, 300); //re-initialise with pins
return true; //success
}
if (found == 0) Serial.println(F("MISSING TOUCHSCREEN"));
//else Serial.println(F("BROKEN TOUCHSCREEN"));
return false;
}
#endif
void setup()
{
char buf[40];
uint16_t ID = readID();
TFT_BEGIN();
tft.fillScreen(TFT_NAVY);
tft.println("Waiting for Serial");
delay(1000);
Serial.begin(9600);
while (!Serial);
tft.fillScreen(TFT_BLUE);
Serial.println(TITLE);
bool ret = true;
#if USE_XPT2046 || defined(__arm__) || defined(ESP32)
Serial.println(F("Not possible to diagnose Touch pins on ARM or ESP32"));
#else
ret = diagnose_pins(); //destroys TFT pin modes
TFT_BEGIN(); //start again
#endif
tft.setRotation(TOUCH_ORIENTATION);
dispx = tft.width();
dispy = tft.height();
text_y_center = (dispy / 2) - 6;
sprintf(buf, "ID = 0x%04x", ID);
Serial.println(buf);
if (ret == false) {
centerprint("BROKEN TOUCHSCREEN", text_y_center);
fail();
}
}
void loop()
{
startup();
int x, y, cnt, idx = 0;
tft.fillScreen(BLACK);
for (x = 10, cnt = 0; x < dispx; x += (dispx - 20) / 2) {
for (y = 10; y < dispy; y += (dispy - 20) / 2) {
if (++cnt != 5) drawCrossHair(x, y, GRAY);
}
}
centerprint("***********", text_y_center - 12);
centerprint("***********", text_y_center + 12);
for (x = 10, cnt = 0; x < dispx; x += (dispx - 20) / 2) {
for (y = 10; y < dispy; y += (dispy - 20) / 2) {
if (++cnt != 5) calibrate(x, y, idx++, F(" X, Y, Pressure"));
}
}
cals = (long(dispx - 1) << 12) + (dispy - 1);
swapxy = rx[2] - rx[0];
//else swapxy = ry[2] - ry[0];
swapxy = (swapxy < -400 || swapxy > 400);
if (swapxy != 0) {
clx = (ry[0] + ry[1] + ry[2]); //rotate 90
crx = (ry[5] + ry[6] + ry[7]);
cty = (rx[0] + rx[3] + rx[5]);
cby = (rx[2] + rx[4] + rx[7]);
} else {
clx = (rx[0] + rx[1] + rx[2]); //regular
crx = (rx[5] + rx[6] + rx[7]);
cty = (ry[0] + ry[3] + ry[5]);
cby = (ry[2] + ry[4] + ry[7]);
}
clx /= 3;
crx /= 3;
cty /= 3;
cby /= 3;
px = float(crx - clx) / (dispx - 20);
py = float(cby - cty) / (dispy - 20);
// px = 0;
clx -= px * 10;
crx += px * 10;
cty -= py * 10;
cby += py * 10;
calx = (long(clx) << 14) + long(crx);
caly = (long(cty) << 14) + long(cby);
if (swapxy)
cals |= (1L << 31);
report(); // report results
while (true) {} // tread water
}
void readCoordinates()
{
int iter = 5000;
int failcount = 0;
int cnt = 0;
uint32_t tx = 0;
uint32_t ty = 0;
uint32_t tz = 0;
bool OK = false;
while (OK == false)
{
centerprint("* PRESS *", text_y_center);
while (ISPRESSED() == false) {}
centerprint("* HOLD! *", text_y_center);
cnt = 0;
iter = 400;
do
{
readResistiveTouch();
if (tp.z > 200) //.kbv
{
tx += tp.x;
ty += tp.y;
tz += tp.z;
cnt++;
}
else
failcount++;
} while ((cnt < iter) && (failcount < 10000));
if (cnt >= iter)
{
OK = true;
}
else
{
tx = 0;
ty = 0;
tz = 0;
cnt = 0;
}
if (failcount >= 10000)
fail();
}
cx = tx / iter;
cy = ty / iter;
cz = tz / iter;
}
void calibrate(int x, int y, int i, String msg)
{
drawCrossHair(x, y, WHITE);
readCoordinates();
centerprint("* RELEASE *", text_y_center);
drawCrossHair(x, y, GRAY_DONE);
rx[i] = cx;
ry[i] = cy;
char buf[40];
sprintf(buf, "\r\ncx=%ld cy=%ld cz=%ld %s", cx, cy, cz, msg.c_str());
Serial.print(buf);
while (ISPRESSED() == true) {}
}
void report()
{
uint16_t TS_LEFT, TS_RT, TS_TOP, TS_BOT, TS_WID, TS_HT, TS_SWAP;
int16_t tmp;
char buf[60];
centertitle(TITLE);
tft.println(F("To use the new calibration"));
tft.println(F("settings you must map the values"));
tft.println(F("from Point p = ts.getPoint() e.g. "));
tft.println(F("x = map(p.x, LEFT, RT, 0, tft.width());"));
tft.println(F("y = map(p.y, TOP, BOT, 0, tft.height());"));
tft.println(F("swap p.x and p.y if diff ORIENTATION"));
//.kbv show human values
TS_LEFT = (calx >> 14) & 0x3FFF;
TS_RT = (calx >> 0) & 0x3FFF;
TS_TOP = (caly >> 14) & 0x3FFF;
TS_BOT = (caly >> 0) & 0x3FFF;
TS_WID = ((cals >> 12) & 0x0FFF) + 1;
TS_HT = ((cals >> 0) & 0x0FFF) + 1;
TS_SWAP = (cals >> 31);
if (TOUCH_ORIENTATION == LANDSCAPE) { //always show PORTRAIT first
tmp = TS_LEFT, TS_LEFT = TS_BOT, TS_BOT = TS_RT, TS_RT = TS_TOP, TS_TOP = tmp;
tmp = TS_WID, TS_WID = TS_HT, TS_HT = tmp;
}
sprintf(buf, "\n\n*** COPY-PASTE from Serial Terminal:");
bofe(buf);
bool ts_landscape = (TOUCH_ORIENTATION == LANDSCAPE) ^ swapxy;
#if (USE_XPT2046)
sprintf(buf, "const int TS_LANDSCAPE=%d; //%s", ts_landscape, TITLE);
bofe(buf);
#else
if (ts_landscape) {
SWAP(XM, YP);
SWAP(XP, YM);
SWAP(TS_LEFT, TS_RT);
SWAP(TS_TOP, TS_BOT);
}
sprintf(buf, "const int XP=%d,XM=%s,YP=%s,YM=%d; //%dx%d ID=0x%04X",
XP, Aval(XM), Aval(YP), YM, TS_WID, TS_HT, readID());
Serial.println(buf);
sprintf(buf, "\nTouch Pin Wiring XP=%d XM=%s YP=%s YM=%d",
XP, Aval(XM), Aval(YP), YM);
tft.println(buf);
#endif
sprintf(buf, "const int TS_LEFT=%d,TS_RT=%d,TS_TOP=%d,TS_BOT=%d;",
TS_LEFT, TS_RT, TS_TOP, TS_BOT);
Serial.println(buf);
#if !defined(ARDUINO_AVR_LEONARDO)
for (int orient = 0; orient < 2; orient++) {
sprintf(buf, "\n%s CALIBRATION %d x %d",
orient ? "LANDSCAPE" : "PORTRAIT ", TS_WID, TS_HT);
bofe(buf);
sprintf(buf, "x = map(p.%s, LEFT=%d, RT=%d, 0, %d)",
orient ? "y" : "x", TS_LEFT, TS_RT, TS_WID);
bofe(buf);
sprintf(buf, "y = map(p.%s, TOP=%d, BOT=%d, 0, %d)",
orient ? "x" : "y", TS_TOP, TS_BOT, TS_HT);
bofe(buf);
tmp = TS_LEFT, TS_LEFT = TS_TOP, TS_TOP = TS_RT, TS_RT = TS_BOT, TS_BOT = tmp;
tmp = TS_WID, TS_WID = TS_HT, TS_HT = tmp;
}
int16_t x_range = TS_LEFT - TS_RT, y_range = TS_TOP - TS_BOT;
if (abs(x_range) > 500 && abs(y_range) > 650) //LANDSCAPE
return;
sprintf(buf, "\n*** UNUSUAL CALIBRATION RANGES %d %d", x_range, y_range);
bofe(buf);
#endif
}
void drawCrossHair(int x, int y, uint16_t color)
{
tft.drawRect(x - 10, y - 10, 20, 20, color);
tft.drawLine(x - 5, y, x + 5, y, color);
tft.drawLine(x, y - 5, x, y + 5, color);
}
void centerprint(const char *s, int y)
{
int len = strlen(s) * 6;
tft.setTextColor(WHITE, RED);
tft.setCursor((dispx - len) / 2, y);
tft.print(s);
}
void centertitle(const char *s)
{
tft.fillScreen(BLACK);
tft.fillRect(0, 0, dispx, 14, RED);
tft.fillRect(0, 14, dispx, 1, WHITE);
centerprint(s, 1);
tft.setCursor(0, 30);
tft.setTextColor(WHITE, BLACK);
}
void startup()
{
centertitle(TITLE);
tft.println(F("#define NUMSAMPLES 3 in Library\n"));
tft.println(F("Use a stylus or something"));
tft.println(F("similar to touch as close"));
tft.println(F("to the center of the WHITE"));
tft.println(F("crosshair. Keep holding"));
tft.println(F("until crosshair turns RED."));
tft.println(F("Repeat for all crosshairs.\n"));
tft.println(F("Report can be pasted from Serial\n"));
tft.println(F("Touch screen to continue"));
while (ISPRESSED() == false) {}
while (ISPRESSED() == true) {}
// waitForTouch();
}
void fail()
{
centertitle("Touch Calibration FAILED");
tft.println(F("Unable to read the position"));
tft.println(F("of the press. This is a"));
tft.println(F("hardware issue and can not"));
tft.println(F("be corrected in software."));
tft.println(F("check XP, XM pins with a multimeter"));
tft.println(F("check YP, YM pins with a multimeter"));
tft.println(F("should be about 300 ohms"));
while (true) {};
}
libraries/MCUFRIEND_kbv/examples/TouchScreen_Calibr_native/TouchScreen_kbv.cpp
+181
View File
@@ -0,0 +1,181 @@
// Touch screen library with X Y and Z (pressure) readings as well
// as oversampling to avoid 'bouncing'
// adapted from (c) ladyada / adafruit
#include "Arduino.h"
#include "TouchScreen_kbv.h"
#define NUMSAMPLES 3 //.kbv
#if defined(__STM32F1__) || defined(ESP32) //Maple core
#define ADC_ADJUST >>2
#else
#define ADC_ADJUST
#endif
TSPoint_kbv::TSPoint_kbv(void) {
x = y = 0;
}
TSPoint_kbv::TSPoint_kbv(int16_t x0, int16_t y0, int16_t z0) {
x = x0;
y = y0;
z = z0;
}
bool TSPoint_kbv::operator==(TSPoint_kbv p1) {
return ((p1.x == x) && (p1.y == y) && (p1.z == z));
}
bool TSPoint_kbv::operator!=(TSPoint_kbv p1) {
return ((p1.x != x) || (p1.y != y) || (p1.z != z));
}
static void insert_sort(int array[], uint8_t size) {
uint8_t j;
int save;
for (int i = 1; i < size; i++) {
save = array[i];
for (j = i; j >= 1 && save < array[j - 1]; j--)
array[j] = array[j - 1];
array[j] = save;
}
}
TSPoint_kbv TouchScreen_kbv::getPoint(void) {
int x, y, z;
int samples[NUMSAMPLES];
uint8_t i, valid;
valid = 1;
pinMode(_yp, INPUT);
pinMode(_ym, INPUT);
digitalWrite(_yp, LOW);
digitalWrite(_ym, LOW);
pinMode(_xp, OUTPUT);
pinMode(_xm, OUTPUT);
digitalWrite(_xp, HIGH);
digitalWrite(_xm, LOW);
for (i = 0; i < NUMSAMPLES; i++) {
samples[i] = analogRead(_yp) ADC_ADJUST;
}
insert_sort(samples, NUMSAMPLES);
x = (1023 - samples[NUMSAMPLES / 2]); //choose median
pinMode(_xp, INPUT);
pinMode(_xm, INPUT);
digitalWrite(_xp, LOW);
digitalWrite(_xm, LOW); //.kbv for Due
pinMode(_yp, OUTPUT);
digitalWrite(_yp, HIGH);
pinMode(_ym, OUTPUT);
digitalWrite(_ym, LOW); //.kbv for Due
for (i = 0; i < NUMSAMPLES; i++) {
samples[i] = analogRead(_xm) ADC_ADJUST;
}
insert_sort(samples, NUMSAMPLES);
y = (1023 - samples[NUMSAMPLES / 2]);
// Set X+ to ground
pinMode(_xp, OUTPUT);
digitalWrite(_xp, LOW);
// Set Y- to VCC
pinMode(_ym, OUTPUT); //.kbv
digitalWrite(_ym, HIGH);
// Hi-Z X- and Y+
digitalWrite(_xm, LOW); //.kbv
pinMode(_xm, INPUT); //.kbv
digitalWrite(_yp, LOW);
pinMode(_yp, INPUT);
int z1 = analogRead(_xm) ADC_ADJUST;
int z2 = analogRead(_yp) ADC_ADJUST;
z = (1023 - (z2 - z1));
return TSPoint_kbv(x, y, z); //XM, YP still in ANALOG mode
}
TouchScreen_kbv::TouchScreen_kbv(uint8_t xp, uint8_t yp, uint8_t xm, uint8_t ym) {
_yp = yp;
_xm = xm;
_ym = ym;
_xp = xp;
_rxplate = 0;
pressureThreshhold = 10;
}
TouchScreen_kbv::TouchScreen_kbv(uint8_t xp, uint8_t yp, uint8_t xm, uint8_t ym,
uint16_t rxplate) {
_yp = yp;
_xm = xm;
_ym = ym;
_xp = xp;
_rxplate = rxplate;
pressureThreshhold = 10;
}
int TouchScreen_kbv::readTouchX(void) {
pinMode(_yp, INPUT);
pinMode(_ym, INPUT);
digitalWrite(_yp, LOW);
digitalWrite(_ym, LOW);
pinMode(_xp, OUTPUT);
digitalWrite(_xp, HIGH);
pinMode(_xm, OUTPUT);
digitalWrite(_xm, LOW);
return (1023 - (analogRead(_yp)) ADC_ADJUST);
}
int TouchScreen_kbv::readTouchY(void) {
pinMode(_xp, INPUT);
pinMode(_xm, INPUT);
digitalWrite(_xp, LOW);
digitalWrite(_xm, LOW);
pinMode(_yp, OUTPUT);
digitalWrite(_yp, HIGH);
pinMode(_ym, OUTPUT);
digitalWrite(_ym, LOW);
return (1023 - (analogRead(_xm)) ADC_ADJUST);
}
uint16_t TouchScreen_kbv::pressure(void) {
// Set X+ to ground
pinMode(_xp, OUTPUT);
digitalWrite(_xp, LOW);
// Set Y- to VCC
pinMode(_ym, OUTPUT);
digitalWrite(_ym, HIGH);
// Hi-Z X- and Y+
digitalWrite(_xm, LOW);
pinMode(_xm, INPUT);
digitalWrite(_yp, LOW);
pinMode(_yp, INPUT);
int z1 = analogRead(_xm) ADC_ADJUST;
int z2 = analogRead(_yp) ADC_ADJUST;
return (1023 - (z2 - z1));
}
libraries/MCUFRIEND_kbv/examples/TouchScreen_Calibr_native/TouchScreen_kbv.h
+39
View File
@@ -0,0 +1,39 @@
// Touch screen library with X Y and Z (pressure) readings as well
// as oversampling to avoid 'bouncing'
// (c) ladyada / adafruit
// Code under MIT License
#ifndef _TOUCHSCREEN_KBV_H_
#define _TOUCHSCREEN_KBV_H_
#include <stdint.h>
class TSPoint_kbv {
public:
TSPoint_kbv(void);
TSPoint_kbv(int16_t x, int16_t y, int16_t z);
bool operator==(TSPoint_kbv);
bool operator!=(TSPoint_kbv);
int16_t x, y, z;
};
class TouchScreen_kbv {
public:
TouchScreen_kbv(uint8_t xp, uint8_t yp, uint8_t xm, uint8_t ym);
TouchScreen_kbv(uint8_t xp, uint8_t yp, uint8_t xm, uint8_t ym, uint16_t rx);
// bool isTouching(void);
uint16_t pressure(void);
int readTouchY();
int readTouchX();
TSPoint_kbv getPoint();
int16_t pressureThreshhold;
private:
uint8_t _yp, _ym, _xm, _xp;
uint16_t _rxplate;
};
#endif
libraries/MCUFRIEND_kbv/examples/Touch_shield_new/Touch_shield_new.ino
+202
View File
@@ -0,0 +1,202 @@
// the regular Adafruit "TouchScreen.h" library only works on AVRs
// different mcufriend shields have Touchscreen on different pins
// and rotation.
// Run the TouchScreen_Calibr_native sketch for calibration of your shield
#include <MCUFRIEND_kbv.h>
MCUFRIEND_kbv tft; // hard-wired for UNO shields anyway.
#include <TouchScreen.h>
char *name = "Please Calibrate."; //edit name of shield
const int XP=6,XM=A2,YP=A1,YM=7; //ID=0x9341
const int TS_LEFT=907,TS_RT=136,TS_TOP=942,TS_BOT=139;
TouchScreen ts = TouchScreen(XP, YP, XM, YM, 300);
TSPoint tp;
#define MINPRESSURE 200
#define MAXPRESSURE 1000
int16_t BOXSIZE;
int16_t PENRADIUS = 1;
uint16_t ID, oldcolor, currentcolor;
uint8_t Orientation = 0; //PORTRAIT
// Assign human-readable names to some common 16-bit color values:
#define BLACK 0x0000
#define BLUE 0x001F
#define RED 0xF800
#define GREEN 0x07E0
#define CYAN 0x07FF
#define MAGENTA 0xF81F
#define YELLOW 0xFFE0
#define WHITE 0xFFFF
void show_Serial(void)
{
Serial.println(F("Most Touch Screens use pins 6, 7, A1, A2"));
Serial.println(F("But they can be in ANY order"));
Serial.println(F("e.g. right to left or bottom to top"));
Serial.println(F("or wrong direction"));
Serial.println(F("Edit name and calibration statements\n"));
Serial.println(name);
Serial.print(F("ID=0x"));
Serial.println(ID, HEX);
Serial.println("Screen is " + String(tft.width()) + "x" + String(tft.height()));
Serial.println("Calibration is: ");
Serial.println("LEFT = " + String(TS_LEFT) + " RT = " + String(TS_RT));
Serial.println("TOP = " + String(TS_TOP) + " BOT = " + String(TS_BOT));
Serial.println("Wiring is always PORTRAIT");
Serial.println("YP=" + String(YP) + " XM=" + String(XM));
Serial.println("YM=" + String(YM) + " XP=" + String(XP));
}
void show_tft(void)
{
tft.setCursor(0, 0);
tft.setTextSize(1);
tft.print(F("ID=0x"));
tft.println(ID, HEX);
tft.println("Screen is " + String(tft.width()) + "x" + String(tft.height()));
tft.println("");
tft.setTextSize(2);
tft.println(name);
tft.setTextSize(1);
tft.println("PORTRAIT Values:");
tft.println("LEFT = " + String(TS_LEFT) + " RT = " + String(TS_RT));
tft.println("TOP = " + String(TS_TOP) + " BOT = " + String(TS_BOT));
tft.println("\nWiring is: ");
tft.println("YP=" + String(YP) + " XM=" + String(XM));
tft.println("YM=" + String(YM) + " XP=" + String(XP));
tft.setTextSize(2);
tft.setTextColor(RED);
tft.setCursor((tft.width() - 48) / 2, (tft.height() * 2) / 4);
tft.print("EXIT");
tft.setTextColor(YELLOW, BLACK);
tft.setCursor(0, (tft.height() * 6) / 8);
tft.print("Touch screen for loc");
while (1) {
tp = ts.getPoint();
pinMode(XM, OUTPUT);
pinMode(YP, OUTPUT);
if (tp.z < MINPRESSURE || tp.z > MAXPRESSURE) continue;
if (tp.x > 450 && tp.x < 570 && tp.y > 450 && tp.y < 570) break;
tft.setCursor(0, (tft.height() * 3) / 4);
tft.print("tp.x=" + String(tp.x) + " tp.y=" + String(tp.y) + " ");
}
}
void setup(void)
{
uint16_t tmp;
tft.reset();
ID = tft.readID();
tft.begin(ID);
Serial.begin(9600);
show_Serial();
tft.setRotation(Orientation);
tft.fillScreen(BLACK);
show_tft();
BOXSIZE = tft.width() / 6;
tft.fillScreen(BLACK);
tft.fillRect(0, 0, BOXSIZE, BOXSIZE, RED);
tft.fillRect(BOXSIZE, 0, BOXSIZE, BOXSIZE, YELLOW);
tft.fillRect(BOXSIZE * 2, 0, BOXSIZE, BOXSIZE, GREEN);
tft.fillRect(BOXSIZE * 3, 0, BOXSIZE, BOXSIZE, CYAN);
tft.fillRect(BOXSIZE * 4, 0, BOXSIZE, BOXSIZE, BLUE);
tft.fillRect(BOXSIZE * 5, 0, BOXSIZE, BOXSIZE, MAGENTA);
tft.drawRect(0, 0, BOXSIZE, BOXSIZE, WHITE);
currentcolor = RED;
delay(1000);
}
void loop()
{
uint16_t xpos, ypos; //screen coordinates
tp = ts.getPoint(); //tp.x, tp.y are ADC values
// if sharing pins, you'll need to fix the directions of the touchscreen pins
pinMode(XM, OUTPUT);
pinMode(YP, OUTPUT);
// we have some minimum pressure we consider 'valid'
// pressure of 0 means no pressing!
if (tp.z > MINPRESSURE && tp.z < MAXPRESSURE) {
// most mcufriend have touch (with icons) that extends below the TFT
// screens without icons need to reserve a space for "erase"
// scale the ADC values from ts.getPoint() to screen values e.g. 0-239
//
// Calibration is true for PORTRAIT. tp.y is always long dimension
// map to your current pixel orientation
switch (Orientation) {
case 0:
xpos = map(tp.x, TS_LEFT, TS_RT, 0, tft.width());
ypos = map(tp.y, TS_TOP, TS_BOT, 0, tft.height());
break;
case 1:
xpos = map(tp.y, TS_TOP, TS_BOT, 0, tft.width());
ypos = map(tp.x, TS_RT, TS_LEFT, 0, tft.height());
break;
case 2:
xpos = map(tp.x, TS_RT, TS_LEFT, 0, tft.width());
ypos = map(tp.y, TS_BOT, TS_TOP, 0, tft.height());
break;
case 3:
xpos = map(tp.y, TS_BOT, TS_TOP, 0, tft.width());
ypos = map(tp.x, TS_LEFT, TS_RT, 0, tft.height());
break;
}
// are we in top color box area ?
if (ypos < BOXSIZE) { //draw white border on selected color box
oldcolor = currentcolor;
if (xpos < BOXSIZE) {
currentcolor = RED;
tft.drawRect(0, 0, BOXSIZE, BOXSIZE, WHITE);
} else if (xpos < BOXSIZE * 2) {
currentcolor = YELLOW;
tft.drawRect(BOXSIZE, 0, BOXSIZE, BOXSIZE, WHITE);
} else if (xpos < BOXSIZE * 3) {
currentcolor = GREEN;
tft.drawRect(BOXSIZE * 2, 0, BOXSIZE, BOXSIZE, WHITE);
} else if (xpos < BOXSIZE * 4) {
currentcolor = CYAN;
tft.drawRect(BOXSIZE * 3, 0, BOXSIZE, BOXSIZE, WHITE);
} else if (xpos < BOXSIZE * 5) {
currentcolor = BLUE;
tft.drawRect(BOXSIZE * 4, 0, BOXSIZE, BOXSIZE, WHITE);
} else if (xpos < BOXSIZE * 6) {
currentcolor = MAGENTA;
tft.drawRect(BOXSIZE * 5, 0, BOXSIZE, BOXSIZE, WHITE);
}
if (oldcolor != currentcolor) { //rub out the previous white border
if (oldcolor == RED) tft.fillRect(0, 0, BOXSIZE, BOXSIZE, RED);
if (oldcolor == YELLOW) tft.fillRect(BOXSIZE, 0, BOXSIZE, BOXSIZE, YELLOW);
if (oldcolor == GREEN) tft.fillRect(BOXSIZE * 2, 0, BOXSIZE, BOXSIZE, GREEN);
if (oldcolor == CYAN) tft.fillRect(BOXSIZE * 3, 0, BOXSIZE, BOXSIZE, CYAN);
if (oldcolor == BLUE) tft.fillRect(BOXSIZE * 4, 0, BOXSIZE, BOXSIZE, BLUE);
if (oldcolor == MAGENTA) tft.fillRect(BOXSIZE * 5, 0, BOXSIZE, BOXSIZE, MAGENTA);
}
}
// are we in drawing area ?
if (((ypos - PENRADIUS) > BOXSIZE) && ((ypos + PENRADIUS) < tft.height())) {
tft.fillCircle(xpos, ypos, PENRADIUS, currentcolor);
}
// are we in erase area ?
// Plain Touch panels use bottom 10 pixels e.g. > h - 10
// Touch panels with icon area e.g. > h - 0
if (ypos > tft.height() - 10) {
// press the bottom of the screen to erase
tft.fillRect(0, BOXSIZE, tft.width(), tft.height() - BOXSIZE, BLACK);
}
}
}
libraries/MCUFRIEND_kbv/examples/aspect_kbv/aspect_kbv.ino
+40
View File
@@ -0,0 +1,40 @@
#include <Adafruit_GFX.h> // Hardware-specific library
#include <MCUFRIEND_kbv.h>
MCUFRIEND_kbv tft;
void setup()
{
// put your setup code here, to run once:
Serial.begin(9600);
tft.reset();
uint16_t identifier = tft.readID();
Serial.print("ID = 0x");
Serial.println(identifier, HEX);
if (identifier == 0xEFEF) identifier = 0x9486;
tft.begin(identifier);
// tft.fillScreen(BLACK);
}
char *msg[] = { "PORTRAIT", "LANDSCAPE", "PORTRAIT_REV", "LANDSCAPE_REV" };
uint8_t aspect;
void loop()
{
// put your main code here, to run repeatedly:
uint16_t x = 50, y = 100;
tft.setRotation(aspect);
tft.fillScreen(0x0000);
tft.setCursor(0, 0);
tft.setTextSize(2);
tft.println(msg[aspect]);
tft.setCursor(x, y);
tft.println("[x=" + String(x) + ",y=" + String(y) + "]");
delay(5000);
tft.println("INVERT ON");
tft.invertDisplay(true);
delay(1000);
tft.invertDisplay(false);
tft.println("INVERT OFF");
delay(1000);
if (++aspect >= 4) aspect = 0;
}
libraries/MCUFRIEND_kbv/examples/button_simple/button_list.ino
+116
View File
@@ -0,0 +1,116 @@
/* an alternative approach. swap the #if 1 / 0 values to try it
*
*/
#if 0
#include <Adafruit_GFX.h>
#include <MCUFRIEND_kbv.h>
MCUFRIEND_kbv tft;
#include <TouchScreen.h>
#define MINPRESSURE 200
#define MAXPRESSURE 1000
// ALL Touch panels and wiring is DIFFERENT
// copy-paste results from TouchScreen_Calibr_native.ino
const int XP = 6, XM = A2, YP = A1, YM = 7; //ID=0x9341
const int TS_LEFT = 907, TS_RT = 136, TS_TOP = 942, TS_BOT = 139;
TouchScreen ts = TouchScreen(XP, YP, XM, YM, 300);
Adafruit_GFX_Button on_btn, off_btn;
int pixel_x, pixel_y; //Touch_getXY() updates global vars
bool Touch_getXY(void)
{
TSPoint p = ts.getPoint();
pinMode(YP, OUTPUT); //restore shared pins
pinMode(XM, OUTPUT);
digitalWrite(YP, HIGH); //because TFT control pins
digitalWrite(XM, HIGH);
bool pressed = (p.z > MINPRESSURE && p.z < MAXPRESSURE);
if (pressed) {
pixel_x = map(p.x, TS_LEFT, TS_RT, 0, tft.width()); //.kbv makes sense to me
pixel_y = map(p.y, TS_TOP, TS_BOT, 0, tft.height());
}
return pressed;
}
#define BLACK 0x0000
#define BLUE 0x001F
#define RED 0xF800
#define GREEN 0x07E0
#define CYAN 0x07FF
#define MAGENTA 0xF81F
#define YELLOW 0xFFE0
#define WHITE 0xFFFF
void setup(void)
{
Serial.begin(9600);
uint16_t ID = tft.readID();
Serial.print("TFT ID = 0x");
Serial.println(ID, HEX);
Serial.println("Calibrate for your Touch Panel");
if (ID == 0xD3D3) ID = 0x9486; // write-only shield
tft.begin(ID);
tft.setRotation(0); //PORTRAIT
tft.fillScreen(BLACK);
on_btn.initButton(&tft, 60, 200, 100, 40, WHITE, CYAN, BLACK, "ON", 2);
off_btn.initButton(&tft, 180, 200, 100, 40, WHITE, CYAN, BLACK, "OFF", 2);
on_btn.drawButton(false);
off_btn.drawButton(false);
tft.fillRect(40, 80, 160, 80, RED);
}
/*
* updating multiple buttons from a list
*
* anything more than two buttons gets repetitive
*
* you can place button addresses in separate lists
* e.g. for separate menu screens
*/
// Array of button addresses to behave like a list
Adafruit_GFX_Button *buttons[] = {&on_btn, &off_btn, NULL};
/* update the state of a button and redraw as reqd
*
* main program can use isPressed(), justPressed() etc
*/
bool update_button(Adafruit_GFX_Button *b, bool down)
{
b->press(down && b->contains(pixel_x, pixel_y));
if (b->justReleased())
b->drawButton(false);
if (b->justPressed())
b->drawButton(true);
return down;
}
/* most screens have different sets of buttons
* life is easier if you process whole list in one go
*/
bool update_button_list(Adafruit_GFX_Button **pb)
{
bool down = Touch_getXY();
for (int i = 0 ; pb[i] != NULL; i++) {
update_button(pb[i], down);
}
return down;
}
/* compare the simplicity of update_button_list()
*/
void loop(void)
{
update_button_list(buttons); //use helper function
if (on_btn.justPressed()) {
tft.fillRect(40, 80, 160, 80, GREEN);
}
if (off_btn.justPressed()) {
tft.fillRect(40, 80, 160, 80, RED);
}
}
#endif
libraries/MCUFRIEND_kbv/examples/button_simple/button_simple.ino
+84
View File
@@ -0,0 +1,84 @@
#if 1
#include <Adafruit_GFX.h>
#include <MCUFRIEND_kbv.h>
MCUFRIEND_kbv tft;
#include <TouchScreen.h>
#define MINPRESSURE 200
#define MAXPRESSURE 1000
// ALL Touch panels and wiring is DIFFERENT
// copy-paste results from TouchScreen_Calibr_native.ino
const int XP = 6, XM = A2, YP = A1, YM = 7; //ID=0x9341
const int TS_LEFT = 907, TS_RT = 136, TS_TOP = 942, TS_BOT = 139;
TouchScreen ts = TouchScreen(XP, YP, XM, YM, 300);
Adafruit_GFX_Button on_btn, off_btn;
int pixel_x, pixel_y; //Touch_getXY() updates global vars
bool Touch_getXY(void)
{
TSPoint p = ts.getPoint();
pinMode(YP, OUTPUT); //restore shared pins
pinMode(XM, OUTPUT);
digitalWrite(YP, HIGH); //because TFT control pins
digitalWrite(XM, HIGH);
bool pressed = (p.z > MINPRESSURE && p.z < MAXPRESSURE);
if (pressed) {
pixel_x = map(p.x, TS_LEFT, TS_RT, 0, tft.width()); //.kbv makes sense to me
pixel_y = map(p.y, TS_TOP, TS_BOT, 0, tft.height());
}
return pressed;
}
#define BLACK 0x0000
#define BLUE 0x001F
#define RED 0xF800
#define GREEN 0x07E0
#define CYAN 0x07FF
#define MAGENTA 0xF81F
#define YELLOW 0xFFE0
#define WHITE 0xFFFF
void setup(void)
{
Serial.begin(9600);
uint16_t ID = tft.readID();
Serial.print("TFT ID = 0x");
Serial.println(ID, HEX);
Serial.println("Calibrate for your Touch Panel");
if (ID == 0xD3D3) ID = 0x9486; // write-only shield
tft.begin(ID);
tft.setRotation(0); //PORTRAIT
tft.fillScreen(BLACK);
on_btn.initButton(&tft, 60, 200, 100, 40, WHITE, CYAN, BLACK, "ON", 2);
off_btn.initButton(&tft, 180, 200, 100, 40, WHITE, CYAN, BLACK, "OFF", 2);
on_btn.drawButton(false);
off_btn.drawButton(false);
tft.fillRect(40, 80, 160, 80, RED);
}
/* two buttons are quite simple
*/
void loop(void)
{
bool down = Touch_getXY();
on_btn.press(down && on_btn.contains(pixel_x, pixel_y));
off_btn.press(down && off_btn.contains(pixel_x, pixel_y));
if (on_btn.justReleased())
on_btn.drawButton();
if (off_btn.justReleased())
off_btn.drawButton();
if (on_btn.justPressed()) {
on_btn.drawButton(true);
tft.fillRect(40, 80, 160, 80, GREEN);
}
if (off_btn.justPressed()) {
off_btn.drawButton(true);
tft.fillRect(40, 80, 160, 80, RED);
}
}
#endif
libraries/MCUFRIEND_kbv/examples/diagnose_TFT_support/diagnose_TFT_support.ino
+126
View File
@@ -0,0 +1,126 @@
#include <MCUFRIEND_kbv.h>
MCUFRIEND_kbv tft;
// Assign human-readable names to some common 16-bit color values:
#define BLACK 0x0000
#define BLUE 0x001F
#define RED 0xF800
#define GREEN 0x07E0
#define CYAN 0x07FF
#define MAGENTA 0xF81F
#define YELLOW 0xFFE0
#define WHITE 0xFFFF
#define GRAY 0x8410
uint16_t version = MCUFRIEND_KBV_H_;
void setup()
{
Serial.begin(9600);
if (!Serial) delay(5000); //allow some time for Leonardo
uint16_t ID = tft.readID(); //
Serial.println(F("Diagnose whether this controller is supported"));
Serial.println(F("There are FAQs in extras/mcufriend_how_to.txt"));
Serial.println(F(""));
Serial.print(F("tft.readID() finds: ID = 0x"));
Serial.println(ID, HEX);
Serial.println(F(""));
Serial.print(F("MCUFRIEND_kbv version: "));
Serial.print(version/100);
Serial.print(F("."));
Serial.print((version / 10) % 10);
Serial.print(F("."));
Serial.println(version % 10);
Serial.println(F(""));
if (ID == 0x0404) {
Serial.println(F("Probably a write-only Mega2560 Shield"));
Serial.println(F("#define USE_SPECIAL in mcufriend_shield.h"));
Serial.println(F("#define appropriate SPECIAL in mcufriend_special.h"));
Serial.println(F("e.g. USE_MEGA_16BIT_SHIELD"));
Serial.println(F("e.g. USE_MEGA_8BIT_SHIELD"));
Serial.println(F("Hint. A Mega2560 Shield has a 18x2 male header"));
Serial.println(F("Often a row of resistor-packs near the 18x2"));
Serial.println(F("RP1-RP7 implies 16-bit but it might be 8-bit"));
Serial.println(F("RP1-RP4 or RP1-RP5 can only be 8-bit"));
}
if (ID == 0xD3D3) {
uint16_t guess_ID = 0x9481; // write-only shield
Serial.println(F("Probably a write-only Mega2560 Shield"));
Serial.print(F("Try to force ID = 0x"));
Serial.println(guess_ID, HEX);
tft.begin(guess_ID);
}
else tft.begin(ID);
Serial.println(F(""));
if (tft.width() == 0) {
Serial.println(F("This ID is not supported"));
Serial.println(F("look up ID in extras/mcufriend_how_to.txt"));
Serial.println(F("you may need to edit MCUFRIEND_kbv.cpp"));
Serial.println(F("to enable support for this ID"));
Serial.println(F("e.g. #define SUPPORT_8347D"));
Serial.println(F(""));
Serial.println(F("New controllers appear on Ebay often"));
Serial.println(F("If your ID is not supported"));
Serial.println(F("run LCD_ID_readreg.ino from examples/"));
Serial.println(F("Copy-Paste the output from the Serial Terminal"));
Serial.println(F("to a message in Displays topic on Arduino Forum"));
Serial.println(F("or to Issues on GitHub"));
Serial.println(F(""));
Serial.println(F("Note that OPEN-SMART boards have diff pinout"));
Serial.println(F("Edit the pin defines in LCD_ID_readreg to match"));
Serial.println(F("Edit mcufiend_shield.h for USE_SPECIAL"));
Serial.println(F("Edit mcufiend_special.h for USE_OPENSMART_SHIELD_PINOUT"));
while (1); //just die
} else {
Serial.print(F("PORTRAIT is "));
Serial.print(tft.width());
Serial.print(F(" x "));
Serial.println(tft.height());
Serial.println(F(""));
Serial.println(F("Run the examples/graphictest_kbv sketch"));
Serial.println(F("All colours, text, directions, rotations, scrolls"));
Serial.println(F("should work. If there is a problem, make notes on paper"));
Serial.println(F("Post accurate description of problem to Forum"));
Serial.println(F("Or post a link to a video (or photos)"));
Serial.println(F(""));
Serial.println(F("I rely on good information from remote users"));
}
}
void loop()
{
static uint8_t aspect = 0;
const char *aspectname[] = {
"PORTRAIT", "LANDSCAPE", "PORTRAIT_REV", "LANDSCAPE_REV"
};
const char *colorname[] = { "BLUE", "GREEN", "RED", "GRAY" };
uint16_t colormask[] = { BLUE, GREEN, RED, GRAY };
uint16_t ID = tft.readID(); //
tft.setRotation(aspect);
int width = tft.width();
int height = tft.height();
tft.fillScreen(colormask[aspect]);
tft.drawRect(0, 0, width, height, WHITE);
tft.drawRect(32, 32, width - 64, height - 64, WHITE);
tft.setTextSize(2);
tft.setTextColor(BLACK);
tft.setCursor(40, 40);
tft.print("ID=0x");
tft.print(ID, HEX);
if (ID == 0xD3D3) tft.print(" w/o");
tft.setCursor(40, 70);
tft.print(aspectname[aspect]);
tft.setCursor(40, 100);
tft.print(width);
tft.print(" x ");
tft.print(height);
tft.setTextColor(WHITE);
tft.setCursor(40, 130);
tft.print(colorname[aspect]);
tft.setCursor(40, 160);
tft.setTextSize(1);
tft.print("MCUFRIEND_KBV_H_ = ");
tft.print(version);
if (++aspect > 3) aspect = 0;
delay(5000);
}
libraries/MCUFRIEND_kbv/examples/diagnose_Touchpins/diagnose_Touchpins.ino
+49
View File
@@ -0,0 +1,49 @@
void showpins(int A, int D, int value, const char *msg)
{
Serial.print(msg);
Serial.print(" (A" + String(A - A0) + ", D" + String(D) + ") = ");
Serial.println(value);
}
void setup()
{
int i, j, value, Apins[2], Dpins[2], Values[2], found = 0;
Serial.begin(9600);
Serial.println("Making all control and bus pins INPUT_PULLUP");
Serial.println("Typical 30k Analog pullup with corresponding pin");
Serial.println("would read low when digital is written LOW");
Serial.println("e.g. reads ~25 for 300R X direction");
Serial.println("e.g. reads ~30 for 500R Y direction");
Serial.println("");
for (i = A0; i < A5; i++) pinMode(i, INPUT_PULLUP);
for (i = 2; i < 10; i++) pinMode(i, INPUT_PULLUP);
for (i = A0; i < A4; i++) {
for (j = 5; j < 10; j++) {
pinMode(j, OUTPUT);
digitalWrite(j, LOW);
value = analogRead(i); // ignore first reading
value = analogRead(i);
if (value < 100) {
showpins(i, j, value, "Testing :");
if (found < 2) {
Apins[found] = i;
Dpins[found] = j;
Values[found] = value;
found++;
}
}
pinMode(j, INPUT_PULLUP);
}
}
if (found == 2) {
Serial.println("Diagnosing as:-");
for (i = 0; i < 2; i++) {
showpins(Apins[i], Dpins[i], Values[i], (Values[i] < Values[!i]) ? "XM,XP: " : "YP,YM: ");
}
}
}
void loop()
{
// put your main code here, to run repeatedly:
}
libraries/MCUFRIEND_kbv/examples/drawBitmap_kbv/bitmap_RGB.h
+668
View File
@@ -0,0 +1,668 @@
// several programs can convert BMP, JPG, PNG images to C arrays of pixels
// these used the utility bundled with UTFT.
// Online tool at http://www.rinkydinkelectronics.com/t_imageconverter565.php
// Generated by : ImageConverter 565 v2.3
// Generated from: marilyn_64x64.bmp
// Time generated: 14-May-18 06:55:31
// Dimensions : 64x64 pixels
// Size : 8,192 Bytes
#include <avr/pgmspace.h>
//const unsigned short marilyn_64x64[0x1000] PROGMEM ={
// uint16_t is not ambiguous
const uint16_t marilyn_64x64[0x1000] PROGMEM ={
0x98E5, 0x98E5, 0x98E5, 0x98E5, 0x98E5, 0x98E4, 0x90E4, 0x9905, 0x9905, 0x9104, 0x90E4, 0x9905, 0x9925, 0x9925, 0x9925, 0x9945, // 0x0010 (16)
0x9945, 0x9945, 0x9946, 0xA1A6, 0xAA07, 0xB289, 0xBB4B, 0xCC4F, 0xE5F5, 0xF6B8, 0xF6D9, 0xFEF9, 0xFED8, 0xF6D8, 0xF677, 0xEDD4, // 0x0020 (32)
0xD46F, 0xBAEA, 0xAA08, 0xA186, 0x9966, 0x9966, 0xA166, 0xA166, 0x9946, 0x9946, 0x9945, 0x9926, 0x9926, 0x9946, 0x9925, 0x9925, // 0x0030 (48)
0x9926, 0x9946, 0xA146, 0xA166, 0xA167, 0xA167, 0xA146, 0xA147, 0xA146, 0xA167, 0xA167, 0xA167, 0xA987, 0xA987, 0xA967, 0xA967, // 0x0040 (64)
0x98E5, 0x98E4, 0x98E4, 0x90E4, 0x90E4, 0x90E4, 0x90E4, 0x90E4, 0x9104, 0x90E4, 0x9104, 0x9104, 0x9905, 0x9104, 0x9925, 0x9925, // 0x0050 (80)
0x9965, 0x9966, 0xA1C6, 0xBB0A, 0xC3ED, 0xD511, 0xE5B3, 0xE614, 0xEE34, 0xF6B7, 0xF6F8, 0xFF19, 0xF6D7, 0xEE76, 0xF6D8, 0xF6D8, // 0x0060 (96)
0xF697, 0xE5D5, 0xD4B0, 0xB2CA, 0x9986, 0x9966, 0x9966, 0x9966, 0x9946, 0x9945, 0x9925, 0x9925, 0x9925, 0x9946, 0x9925, 0x9925, // 0x0070 (112)
0x9925, 0x9946, 0x9946, 0xA146, 0xA146, 0xA146, 0x9946, 0xA146, 0xA146, 0xA146, 0xA146, 0xA146, 0xA967, 0xA967, 0xA967, 0xA967, // 0x0080 (128)
0x90C4, 0x90E4, 0x90E4, 0x90E4, 0x90C4, 0x90E4, 0x90E4, 0x90E4, 0x90E4, 0x9104, 0x9104, 0x9104, 0x9104, 0x9104, 0x9124, 0x9945, // 0x0090 (144)
0xAA48, 0xC38C, 0xDD73, 0xF677, 0xF71A, 0xFF3A, 0xF6D7, 0xEE75, 0xEE75, 0xF6B7, 0xF6D8, 0xEE75, 0xE5F3, 0xEE35, 0xF676, 0xF6D8, // 0x00A0 (160)
0xF6D8, 0xEE97, 0xEE77, 0xEE15, 0xCC0E, 0xAA28, 0xA1A6, 0xA186, 0x9945, 0x9945, 0x9945, 0x9925, 0x9945, 0x9945, 0x9925, 0x9925, // 0x00B0 (176)
0x9925, 0x9925, 0x9946, 0x9946, 0x9946, 0x9946, 0x9926, 0xA146, 0xA146, 0x9926, 0xA146, 0xA146, 0xA167, 0xA967, 0xA967, 0xA967, // 0x00C0 (192)
0x90C4, 0x90C4, 0x90C4, 0x90E4, 0x90E4, 0x90E4, 0x9104, 0x9904, 0x9104, 0x9104, 0x9925, 0x9925, 0x9925, 0x9924, 0x9945, 0xAA47, // 0x00D0 (208)
0xD4AF, 0xEE15, 0xF6B7, 0xF697, 0xF697, 0xEE96, 0xF6B7, 0xF6B7, 0xF6D7, 0xF6B7, 0xEE55, 0xD571, 0xCCEF, 0xD530, 0xDD92, 0xE614, // 0x00E0 (224)
0xF6F8, 0xF6D8, 0xEE76, 0xE656, 0xEE35, 0xCC2E, 0xAA28, 0xA9C7, 0xA166, 0x9945, 0x9945, 0x9945, 0x9945, 0x9945, 0x9925, 0x9925, // 0x00F0 (240)
0x9946, 0x9946, 0x9946, 0x9946, 0x9946, 0x9946, 0x9946, 0xA146, 0xA146, 0xA146, 0xA146, 0xA146, 0xA146, 0xA967, 0xA967, 0xA967, // 0x0100 (256)
0x90C4, 0x90E4, 0x90E4, 0x98E4, 0x90E4, 0x9104, 0x9904, 0x9904, 0x9925, 0x9925, 0x9945, 0x9945, 0x9945, 0xA185, 0xB268, 0xD46E, // 0x0110 (272)
0xEE14, 0xEE96, 0xEE96, 0xDDB2, 0xCCEF, 0xBC6D, 0xC4CF, 0xD5B2, 0xE655, 0xEE55, 0xDDB2, 0xD530, 0xC4AE, 0xC46D, 0xD510, 0xD530, // 0x0120 (288)
0xE614, 0xEE55, 0xE676, 0xEE97, 0xEE76, 0xE5B4, 0xC34B, 0xA9E7, 0xA186, 0xA166, 0xA166, 0xA165, 0x9945, 0x9946, 0x9946, 0x9945, // 0x0130 (304)
0x9946, 0x9946, 0x9946, 0xA166, 0xA146, 0xA146, 0x9946, 0xA146, 0xA166, 0xA166, 0xA146, 0xA146, 0xA166, 0xA166, 0xA967, 0xA967, // 0x0140 (320)
0x90E4, 0x90E4, 0x90E4, 0x90E4, 0x9904, 0x9904, 0x9904, 0x9924, 0x9925, 0x9945, 0xA165, 0xA165, 0xA186, 0xAA27, 0xCC4E, 0xDDB2, // 0x0150 (336)
0xEE96, 0xF6D8, 0xE614, 0xC4CF, 0xABCB, 0x9B49, 0x8AE8, 0x9B8A, 0xBCAE, 0xD572, 0xD530, 0xCD0F, 0xC4AE, 0xB3EB, 0xCCAE, 0xD530, // 0x0160 (352)
0xDD91, 0xE5F3, 0xEE76, 0xEE97, 0xEE56, 0xEE77, 0xD48F, 0xB269, 0xA9C7, 0xA1A6, 0xA186, 0xA166, 0xA166, 0xA166, 0xA166, 0xA166, // 0x0170 (368)
0xA146, 0xA146, 0xA166, 0xA166, 0xA166, 0xA166, 0xA166, 0xA166, 0xA167, 0xA166, 0xA166, 0xA166, 0xA166, 0xA987, 0xA987, 0xA987, // 0x0180 (384)
0x90E4, 0x98E4, 0x9904, 0x9904, 0x9904, 0x9904, 0x9925, 0x9945, 0xA165, 0xA165, 0xA186, 0xA9E7, 0xB248, 0xC3CC, 0xD530, 0xE635, // 0x0190 (400)
0xE655, 0xD592, 0xC4F0, 0xAC0C, 0x9B49, 0x8AC8, 0x82A7, 0x7A66, 0x9B8A, 0xBC8E, 0xC4AE, 0xCD10, 0xD530, 0xC46D, 0xCCF0, 0xDD51, // 0x01A0 (416)
0xE5F3, 0xE5D3, 0xEE97, 0xF6D8, 0xEE56, 0xF6D8, 0xE573, 0xCB8C, 0xBAA9, 0xB1E7, 0xA9C7, 0xA1A6, 0xA186, 0xA186, 0xA187, 0xA186, // 0x01B0 (432)
0xA166, 0xA166, 0xA166, 0xA187, 0xA187, 0xA167, 0xA167, 0xA166, 0xA187, 0xA987, 0xA987, 0xA167, 0xA167, 0xA987, 0xA987, 0xA987, // 0x01C0 (448)
0x9904, 0x9904, 0x9905, 0x9925, 0x9925, 0x9925, 0x9925, 0xA166, 0xA186, 0xA1A6, 0xB248, 0xBB2A, 0xCBED, 0xCCCF, 0xDDD3, 0xE614, // 0x01D0 (464)
0xBC4D, 0xA36A, 0x92C8, 0x92E8, 0x9329, 0x8AC8, 0x8287, 0x7A26, 0x9329, 0xB44D, 0xC4CF, 0xDDB2, 0xE614, 0xDD92, 0xE5F4, 0xE615, // 0x01E0 (480)
0xF6B7, 0xEE55, 0xEE96, 0xEE77, 0xE635, 0xFEF9, 0xEE15, 0xDC4E, 0xCB8C, 0xB208, 0xB208, 0xA9C7, 0xA9C7, 0xA9C7, 0xA9A7, 0xA986, // 0x01F0 (496)
0xA186, 0xA186, 0xA9A7, 0xA9A7, 0xA987, 0xA987, 0xA187, 0xA187, 0xA9A7, 0xA9A7, 0xA987, 0xA987, 0xA987, 0xA987, 0xA9A7, 0xA9A7, // 0x0200 (512)
0x9905, 0x9925, 0x9925, 0x9925, 0x9925, 0x9945, 0x9945, 0xA186, 0xA1A6, 0xAA68, 0xBBCC, 0xDD93, 0xE5F4, 0xD592, 0xE635, 0xD591, // 0x0210 (528)
0xC48D, 0xB42C, 0x8AC8, 0x8AA7, 0x9309, 0x9309, 0x8AC8, 0x8AC8, 0xABEC, 0xCCEF, 0xDDD3, 0xEE55, 0xF696, 0xEE34, 0xEE55, 0xEE76, // 0x0220 (544)
0xFF3A, 0xF6F8, 0xE614, 0xDDD3, 0xE635, 0xF6D8, 0xF656, 0xDC8F, 0xDC4F, 0xBAA9, 0xB249, 0xB208, 0xB228, 0xBA69, 0xA9E7, 0xA9A7, // 0x0230 (560)
0xA9A7, 0xA9A7, 0xA9C7, 0xA9A7, 0xA9A7, 0xA9A7, 0xA987, 0xA9A7, 0xA9A7, 0xA9A8, 0xA9A7, 0xA9A7, 0xA9A7, 0xA9A7, 0xA9A7, 0xA9A8, // 0x0240 (576)
0x9925, 0xA125, 0xA145, 0xA145, 0xA145, 0xA165, 0xA166, 0xAA07, 0xAA68, 0x9288, 0x9B4A, 0xCD11, 0xEE76, 0xE635, 0xE5F4, 0xE5F3, // 0x0250 (592)
0xDDB2, 0x9B6A, 0x69A5, 0x7A26, 0x8AE8, 0x9B6A, 0x8AE8, 0xA3CB, 0xC4AE, 0xE614, 0xF6B7, 0xEE76, 0xF6D7, 0xF6B7, 0xEE76, 0xE635, // 0x0260 (608)
0xFF19, 0xF6F8, 0xD571, 0xDDD3, 0xEE56, 0xF697, 0xEE35, 0xE552, 0xE4F0, 0xCBAC, 0xD3CD, 0xDCD1, 0xE573, 0xE552, 0xCBCD, 0xBA69, // 0x0270 (624)
0xB208, 0xB1E7, 0xA9C7, 0xA9C8, 0xA9C8, 0xA9A7, 0xA9A7, 0xA9A7, 0xA9C8, 0xA9C8, 0xA9A8, 0xA9A8, 0xA9A8, 0xA9A8, 0xA9A8, 0xA9A8, // 0x0280 (640)
0x9925, 0xA145, 0xA145, 0xA165, 0xA166, 0xA186, 0xA1C6, 0xAA68, 0xBB6B, 0x8AA8, 0xA38B, 0xCD31, 0xCD51, 0xD571, 0xD5B2, 0xEE76, // 0x0290 (656)
0xE635, 0x934A, 0x69C5, 0x7226, 0x9329, 0xA3CB, 0xA3AB, 0xB44E, 0xCD31, 0xEE96, 0xF6D8, 0xF6B7, 0xEE96, 0xF6B7, 0xEE56, 0xEE55, // 0x02A0 (672)
0xE634, 0xE5F4, 0xDDB3, 0xE635, 0xE655, 0xE635, 0xEE56, 0xE5D4, 0xEDF4, 0xEE35, 0xF656, 0xFED9, 0xF677, 0xEDF4, 0xED94, 0xD42E, // 0x02B0 (688)
0xBA69, 0xB208, 0xB1E8, 0xB1E8, 0xB1E8, 0xA9C8, 0xA9C8, 0xA9C8, 0xA9C8, 0xA9C8, 0xA9C8, 0xB1C8, 0xA9C8, 0xB1C8, 0xB1C8, 0xB1C8, // 0x02C0 (704)
0xA145, 0xA145, 0xA166, 0xA166, 0xA186, 0xA9C7, 0xA9E7, 0xB2A9, 0xBB8B, 0x934A, 0x8AC8, 0x92C8, 0x9B8A, 0xAC0D, 0xC510, 0xDE14, // 0x02D0 (720)
0xD5B3, 0xA3AB, 0x7A68, 0x82E9, 0xA3CC, 0xB46E, 0xC4CF, 0xC4CF, 0xCD31, 0xDDF4, 0xDDF4, 0xDDD4, 0xD592, 0xE614, 0xE614, 0xE635, // 0x02E0 (736)
0xD572, 0xC4F0, 0xCD31, 0xDDB3, 0xCD10, 0xD592, 0xEE76, 0xEE56, 0xF6B7, 0xFEF9, 0xFF19, 0xFED8, 0xF697, 0xF636, 0xEDD4, 0xED52, // 0x02F0 (752)
0xD38C, 0xBA49, 0xB208, 0xB1E8, 0xB1E8, 0xB1E8, 0xB1C8, 0xB1C8, 0xB1E8, 0xB1E8, 0xB1C8, 0xB1C8, 0xB1C8, 0xB1C8, 0xB1C8, 0xB1C8, // 0x0300 (768)
0xA145, 0xA166, 0xA186, 0xA186, 0xA9A6, 0xA9E7, 0xB248, 0xBB6B, 0xC46E, 0x8AE8, 0x8287, 0x92C8, 0xA3AB, 0xB44D, 0xB46E, 0xCD51, // 0x0310 (784)
0xD572, 0xAC0D, 0x7268, 0x934A, 0xBC8E, 0xCCF0, 0xD510, 0xD510, 0xD510, 0xD571, 0xD531, 0xCCF0, 0xC4CF, 0xDD92, 0xCD10, 0xD552, // 0x0320 (800)
0xD551, 0xCCF0, 0xC4AF, 0xA3AB, 0x8AC9, 0xB44E, 0xEE56, 0xFF1A, 0xFF1A, 0xFF1A, 0xFEF9, 0xF696, 0xF6B7, 0xF6B8, 0xF677, 0xF615, // 0x0330 (816)
0xE4F1, 0xCB4C, 0xB228, 0xB208, 0xB1E8, 0xB1E8, 0xB1E8, 0xB1E8, 0xB1E8, 0xB1E8, 0xB1E8, 0xB1E8, 0xB1E8, 0xB1E8, 0xB1E8, 0xB1E8, // 0x0340 (832)
0xA166, 0xA186, 0xA986, 0xA9A6, 0xA9A6, 0xAA07, 0xB2A9, 0xCC8E, 0xCCF0, 0x9B4A, 0x9329, 0xABEC, 0xC4CF, 0xD551, 0xCCEF, 0xC4CF, // 0x0350 (848)
0xD571, 0xBCAF, 0x932A, 0xABCC, 0xDD31, 0xE5B2, 0xEDB2, 0xEDD3, 0xEDF4, 0xEDF4, 0xEDF4, 0xE592, 0xDD52, 0xDD51, 0xDD52, 0xE5B3, // 0x0360 (864)
0xE551, 0xDD31, 0xCCAF, 0xB3ED, 0xA3AB, 0xBC6E, 0xE615, 0xF6B7, 0xFF3A, 0xFF5A, 0xFF19, 0xF697, 0xF6B7, 0xF697, 0xFEF8, 0xFE97, // 0x0370 (880)
0xF5F5, 0xE4B0, 0xC2AA, 0xB229, 0xB208, 0xB1E8, 0xB1E8, 0xB209, 0xB209, 0xB209, 0xB209, 0xB1E9, 0xB209, 0xB209, 0xB209, 0xB1E8, // 0x0380 (896)
0xA986, 0xA986, 0xA9A7, 0xA9A7, 0xA9C7, 0xB207, 0xBAC9, 0xD510, 0xCD10, 0x8B09, 0x7A88, 0xAC2D, 0xE635, 0xE634, 0xC4AE, 0xAC0C, // 0x0390 (912)
0xC4CF, 0xC4CF, 0xB40C, 0xC46D, 0xE591, 0xEDF3, 0xF614, 0xF655, 0xF676, 0xF676, 0xF655, 0xF615, 0xEDF4, 0xF614, 0xF5F4, 0xF5F4, // 0x03A0 (928)
0xEDB3, 0xE572, 0xDD30, 0xCCAF, 0xC46E, 0xCCD0, 0xDDB3, 0xEE76, 0xF719, 0xF6D8, 0xF6B7, 0xEE76, 0xF696, 0xEE55, 0xF6B7, 0xFED8, // 0x03B0 (944)
0xF676, 0xEDB4, 0xD3CD, 0xBA49, 0xB229, 0xB229, 0xB209, 0xB209, 0xB229, 0xB229, 0xB209, 0xB209, 0xB209, 0xBA29, 0xBA09, 0xBA29, // 0x03C0 (960)
0xB1C7, 0xA9C7, 0xB1C7, 0xB1E7, 0xB1E7, 0xB228, 0xBAEA, 0xDD92, 0xCD30, 0x8AE8, 0x7A26, 0x92E8, 0xB42D, 0xC4CF, 0xC4CE, 0xB42D, // 0x03D0 (976)
0x9B8B, 0xBC8E, 0xBC4D, 0xCC8E, 0xE591, 0xF614, 0xF634, 0xFE75, 0xFE97, 0xFE97, 0xFE96, 0xF655, 0xF635, 0xFE56, 0xF655, 0xF655, // 0x03E0 (992)
0xF614, 0xEDD3, 0xE551, 0xD4EF, 0xCC8E, 0xC4AF, 0xCD10, 0xDDB3, 0xE655, 0xE635, 0xEE55, 0xF697, 0xF6B7, 0xEE77, 0xEE35, 0xF655, // 0x03F0 (1008)
0xFEB7, 0xF636, 0xE4F1, 0xBA8A, 0xBA49, 0xBA49, 0xBA29, 0xB229, 0xBA29, 0xBA29, 0xBA29, 0xBA29, 0xBA29, 0xBA29, 0xBA29, 0xBA29, // 0x0400 (1024)
0xB1C7, 0xB1E7, 0xB1E7, 0xB1E7, 0xB207, 0xBA68, 0xC32A, 0xD531, 0xCD51, 0xB42D, 0x9B8B, 0x9329, 0xA38A, 0xABEC, 0xABEB, 0xABCB, // 0x0410 (1040)
0x8AE8, 0x8AA7, 0x9B09, 0xAB8A, 0xD4CE, 0xEDF3, 0xF655, 0xFED7, 0xFED8, 0xFEB7, 0xFEB7, 0xFE96, 0xFE76, 0xFE76, 0xFE76, 0xFE76, // 0x0420 (1056)
0xF634, 0xEDF3, 0xE592, 0xDD30, 0xCCAF, 0xC46E, 0xBC6E, 0xCD31, 0xD592, 0xE635, 0xE614, 0xEE97, 0xF6B8, 0xEE76, 0xEE14, 0xEE34, // 0x0430 (1072)
0xFED8, 0xF636, 0xEDB4, 0xCAEB, 0xBA69, 0xBA69, 0xBA49, 0xBA29, 0xBA29, 0xBA49, 0xBA49, 0xBA29, 0xBA29, 0xBA49, 0xBA49, 0xBA29, // 0x0440 (1088)
0xB1E7, 0xB1E7, 0xB1E7, 0xB1E7, 0xB227, 0xBAA9, 0xC32A, 0xC4AE, 0xBCAF, 0xB44E, 0xAC2D, 0x9B6A, 0xA3EC, 0x9349, 0x8AE8, 0x8AE8, // 0x0450 (1104)
0x9309, 0x8246, 0x8A87, 0x9AC8, 0xC40C, 0xEE14, 0xFED7, 0xFF19, 0xFF19, 0xFEF8, 0xFED8, 0xFEB7, 0xFEB7, 0xFEB7, 0xFEB7, 0xFE76, // 0x0460 (1120)
0xF635, 0xF5F4, 0xEDB2, 0xDD51, 0xD4EF, 0xC46E, 0xB42D, 0xBCAF, 0xD572, 0xE656, 0xDDD3, 0xD571, 0xDDD3, 0xE5F4, 0xE614, 0xF696, // 0x0470 (1136)
0xFEF8, 0xF676, 0xEDD5, 0xCB2C, 0xC28A, 0xBA69, 0xBA69, 0xBA49, 0xBA49, 0xBA49, 0xBA49, 0xBA49, 0xBA49, 0xBA49, 0xBA49, 0xBA49, // 0x0480 (1152)
0xB208, 0xB207, 0xB207, 0xB207, 0xBA48, 0xC2C9, 0xC32A, 0xB3CC, 0x9BAB, 0xAC4D, 0xA42D, 0x936A, 0xAC4D, 0xBCCF, 0xA3EC, 0xA3CC, // 0x0490 (1168)
0xBC6D, 0xBC0C, 0xB3AB, 0xC42C, 0xE5B2, 0xFEB7, 0xFEF8, 0xFF19, 0xFF39, 0xFF19, 0xFEF8, 0xFED8, 0xFED8, 0xFED8, 0xFED8, 0xFE97, // 0x04A0 (1184)
0xF634, 0xEDF3, 0xEDB2, 0xE551, 0xD4F0, 0xC46E, 0xB40D, 0xAC0D, 0xC4F0, 0xC531, 0xDDB3, 0xD551, 0xDD92, 0xE614, 0xEE76, 0xF6B7, // 0x04B0 (1200)
0xF6B7, 0xF697, 0xEDD4, 0xCB4C, 0xC2AA, 0xBA8A, 0xBA69, 0xBA49, 0xBA69, 0xBA69, 0xBA49, 0xBA49, 0xBA49, 0xBA69, 0xC269, 0xC249, // 0x04C0 (1216)
0xBA28, 0xBA28, 0xBA48, 0xBA47, 0xBA88, 0xC34A, 0xC3CC, 0xABAB, 0xA40C, 0xAC6E, 0xAC2D, 0x9BCC, 0xAC6E, 0xCD51, 0xCD31, 0xCD31, // 0x04D0 (1232)
0xD50F, 0xD50F, 0xDD30, 0xEDF3, 0xFEB6, 0xFED7, 0xFEF8, 0xFF39, 0xFF3A, 0xFF3A, 0xFF19, 0xFEF8, 0xFEF9, 0xFF19, 0xFEF9, 0xFEB7, // 0x04E0 (1248)
0xF655, 0xF5F4, 0xED92, 0xDD51, 0xD4F0, 0xC48E, 0xBC2E, 0xABCC, 0xB42D, 0xB48F, 0xD593, 0xDDF4, 0xD571, 0xDDB2, 0xDDD3, 0xEE34, // 0x04F0 (1264)
0xF635, 0xF676, 0xE532, 0xCB0B, 0xC2AA, 0xC28A, 0xBA69, 0xBA69, 0xBA69, 0xBA69, 0xC269, 0xC26A, 0xC269, 0xC26A, 0xC26A, 0xC269, // 0x0500 (1280)
0xBA48, 0xBA48, 0xBA48, 0xBA68, 0xC309, 0xC40C, 0xBC4C, 0xABEC, 0xB4AF, 0xBCCF, 0xAC4D, 0xA40C, 0xB4AF, 0xBCCF, 0xBCCF, 0xCD51, // 0x0510 (1296)
0xC4AE, 0xD4EF, 0xEDD2, 0xF675, 0xFE96, 0xFEB7, 0xFEF8, 0xFF3A, 0xFF7B, 0xFF7B, 0xFF7B, 0xFF3A, 0xFF3A, 0xFF3A, 0xFF1A, 0xFEF9, // 0x0520 (1312)
0xFE96, 0xF635, 0xEDB2, 0xDD51, 0xD510, 0xCCAF, 0xC46E, 0xABED, 0xA3CC, 0xA3ED, 0xC511, 0xD572, 0xD551, 0xDDB2, 0xDD92, 0xE5F3, // 0x0530 (1328)
0xEE14, 0xF635, 0xE4D1, 0xCB0B, 0xC2CA, 0xC28A, 0xC28A, 0xC26A, 0xC28A, 0xC28A, 0xC28A, 0xC28A, 0xC28A, 0xC28A, 0xC28A, 0xC28A, // 0x0540 (1344)
0xBA68, 0xBA68, 0xBA68, 0xC2A9, 0xC3CB, 0xC42C, 0xBC0C, 0xA3EC, 0xC531, 0xBCCF, 0xB46D, 0xB48E, 0xA42D, 0xB46E, 0x9BCB, 0xABCC, // 0x0550 (1360)
0xC46E, 0xDD30, 0xEDF3, 0xEDF4, 0xDD92, 0xE5B2, 0xEE35, 0xF677, 0xF71A, 0xFF5B, 0xFF5B, 0xFF5A, 0xFF5A, 0xFF1A, 0xFF19, 0xFEF8, // 0x0560 (1376)
0xF676, 0xEDF4, 0xDD31, 0xCCAF, 0xB40D, 0xABCC, 0xB40D, 0xB40D, 0xA3AC, 0x9B6B, 0xA3AC, 0xAC2D, 0xCD30, 0xDD92, 0xDD92, 0xE5F3, // 0x0570 (1392)
0xEE35, 0xF635, 0xE4F1, 0xD38C, 0xCAEB, 0xC2AA, 0xC28A, 0xC28A, 0xC28A, 0xC28A, 0xC28A, 0xC28A, 0xC28A, 0xC2AA, 0xC28A, 0xC28A, // 0x0580 (1408)
0xBA68, 0xBA68, 0xC288, 0xC2E9, 0xCC8E, 0xCCCF, 0xB44C, 0xAC2D, 0xC510, 0xB48E, 0xBCCF, 0xC531, 0xAC2D, 0xA3CB, 0xA3EC, 0xBC4D, // 0x0590 (1424)
0xD4CF, 0xDD30, 0xDD51, 0xABCC, 0xA38B, 0xABAB, 0xABAB, 0xABCC, 0xBC6E, 0xD551, 0xEE15, 0xFF19, 0xFF3A, 0xFEF9, 0xFEB7, 0xF697, // 0x05A0 (1440)
0xE5B3, 0xBC4D, 0x930A, 0x8288, 0x7A47, 0x8288, 0x7A89, 0x936B, 0x9B8C, 0x8B0A, 0x9B6B, 0xA3AC, 0xC4CF, 0xE5F3, 0xE5D3, 0xE5F3, // 0x05B0 (1456)
0xEE14, 0xF614, 0xED72, 0xDC2E, 0xCB0B, 0xC2AA, 0xC2AA, 0xC28A, 0xC28A, 0xC28A, 0xC28A, 0xC28A, 0xC28A, 0xC2AA, 0xC2AA, 0xC28A, // 0x05C0 (1472)
0xC288, 0xC289, 0xC2A9, 0xC30A, 0xD4CF, 0xD550, 0xB44C, 0xA42D, 0xBCEF, 0xB48E, 0xDDD3, 0xE676, 0xBCEF, 0xA3EC, 0xABEC, 0xBC2D, // 0x05D0 (1488)
0xCC8E, 0xCC8E, 0xABAB, 0xCCAF, 0xE5B2, 0xE5D3, 0xDD51, 0xCCAE, 0xC44D, 0xC46E, 0xE592, 0xF697, 0xFEF8, 0xFEB8, 0xF635, 0xE592, // 0x05E0 (1504)
0xC42D, 0xA32A, 0x9B0A, 0xB3EC, 0xCC8E, 0xCC6E, 0xB3ED, 0x8B4B, 0x936C, 0x82A9, 0x8B0A, 0x9B4A, 0xC4CF, 0xE614, 0xEE14, 0xE5F3, // 0x05F0 (1520)
0xEE14, 0xEDD3, 0xEDD3, 0xED52, 0xD36C, 0xC2CB, 0xC2AA, 0xC2AA, 0xC2AA, 0xC2AA, 0xC28A, 0xC28A, 0xC2AA, 0xCACA, 0xC2AA, 0xC2AA, // 0x0600 (1536)
0xC288, 0xC2A9, 0xC2A9, 0xC309, 0xD4AE, 0xD571, 0xB44D, 0xA40D, 0xBCCF, 0xC530, 0xD592, 0xC531, 0xA42D, 0x9BAB, 0x9B8B, 0xB3EC, // 0x0610 (1552)
0xBC2D, 0xABCC, 0xC44D, 0xDD51, 0xEDB2, 0xEDD3, 0xEDB2, 0xDD51, 0xDD10, 0xD510, 0xE592, 0xF635, 0xFED8, 0xF697, 0xEDB3, 0xD4AF, // 0x0620 (1568)
0xAB8B, 0xA34A, 0xBC2D, 0xD4AF, 0xD4AF, 0xCC4D, 0xB3CC, 0xAC0E, 0x9BCD, 0x7A48, 0x930A, 0x9B6A, 0xC4AF, 0xE5F4, 0xEE13, 0xE5D2, // 0x0630 (1584)
0xEDF3, 0xEDB3, 0xED93, 0xF5F5, 0xD38C, 0xCACB, 0xC2CA, 0xC2AA, 0xC2AA, 0xC2AA, 0xC2AA, 0xC2AA, 0xC2AA, 0xC2AA, 0xC2AA, 0xC2AA, // 0x0640 (1600)
0xC289, 0xC2A9, 0xC2A9, 0xC309, 0xC3AB, 0xBC6D, 0xB44D, 0x9C0C, 0xC530, 0xC530, 0xBCCF, 0xB48E, 0xA40C, 0x8B4A, 0x9B6A, 0xB3CC, // 0x0650 (1616)
0xB3CC, 0xABAB, 0xCC6E, 0xD4CF, 0xE551, 0xF656, 0xFEB7, 0xF676, 0xEE14, 0xE5B3, 0xDD51, 0xF614, 0xFEB8, 0xFEB8, 0xE572, 0xB3EC, // 0x0660 (1632)
0x9B2A, 0xD4F0, 0xF656, 0xF656, 0xE572, 0xBC0D, 0x9B0A, 0x9B4B, 0xAC4F, 0x7248, 0x9B4B, 0xA3AB, 0xCCCF, 0xDD92, 0xE5D2, 0xEDF3, // 0x0670 (1648)
0xEDF3, 0xF5F4, 0xF5B3, 0xF5D4, 0xD38D, 0xCAEA, 0xCACA, 0xC2AA, 0xC2AA, 0xCAAA, 0xC2AA, 0xC2AA, 0xCAAA, 0xCACB, 0xCACA, 0xCACA, // 0x0680 (1664)
0xC2A9, 0xC2C9, 0xC2C9, 0xC2E9, 0xC3AB, 0xAB8A, 0x9BAA, 0xA40D, 0xC531, 0xB46E, 0xB48E, 0xAC4D, 0x9BCB, 0x8309, 0x9B6B, 0xB3CC, // 0x0690 (1680)
0xB3CC, 0xB3AB, 0xBC2D, 0xCC8E, 0xDD51, 0xDDB3, 0xCD52, 0xC4D0, 0xD531, 0xE5B3, 0xE5B3, 0xEDD3, 0xFE97, 0xFED8, 0xDD31, 0x9B2A, // 0x06A0 (1696)
0xBC4F, 0xDD93, 0xC511, 0xAC2E, 0xABED, 0xABAC, 0x8AC9, 0x8AC9, 0xA40E, 0x7A68, 0x9B6B, 0xABEC, 0xC4AE, 0xDD71, 0xE5D3, 0xE5D2, // 0x06B0 (1712)
0xEDF3, 0xF614, 0xF635, 0xEDB3, 0xD38C, 0xCAEA, 0xCACA, 0xC2CA, 0xC2CA, 0xCACA, 0xCACA, 0xCACA, 0xCACA, 0xCACB, 0xCACA, 0xCACA, // 0x06C0 (1728)
0xC2C9, 0xC2E9, 0xCAE9, 0xC2E9, 0xC329, 0xB3AB, 0x9329, 0x8B6B, 0xAC6E, 0x8B4A, 0x9BCC, 0x9BCC, 0x936B, 0x8B09, 0x936A, 0xABCC, // 0x06D0 (1744)
0xB3EC, 0xB3CC, 0xA38B, 0x930A, 0x7247, 0x5144, 0x4103, 0x6207, 0x934A, 0xC48F, 0xEE15, 0xEDF4, 0xF635, 0xFE97, 0xDD31, 0xA36B, // 0x06E0 (1760)
0xC4B0, 0xA3ED, 0x7AEA, 0x4144, 0x38C2, 0x40E3, 0x59A6, 0x7268, 0xA3ED, 0x82C9, 0x936B, 0xABEC, 0xBC4C, 0xD530, 0xEE34, 0xEE34, // 0x06F0 (1776)
0xEDF3, 0xEDD3, 0xF676, 0xEDB3, 0xD38C, 0xCAEB, 0xCAEA, 0xC2CA, 0xC2CA, 0xCACA, 0xCACA, 0xCACA, 0xCACA, 0xCACB, 0xCACB, 0xCACB, // 0x0700 (1792)
0xC2C9, 0xCAE9, 0xCAEA, 0xCB0A, 0xCB0A, 0xBB09, 0x8A67, 0x7A88, 0x8B2A, 0x59A5, 0x7AC9, 0x9BEC, 0xA40C, 0x936A, 0x936B, 0xABEC, // 0x0710 (1808)
0xC46E, 0xCCAF, 0xBC4E, 0x7A88, 0x6A06, 0x8B2A, 0xB46E, 0xCCF0, 0xDDB3, 0xEE56, 0xF656, 0xEE14, 0xEE14, 0xF656, 0xDD52, 0xB40D, // 0x0720 (1824)
0xCCCF, 0xDD72, 0xDD72, 0xBC8F, 0xA3AC, 0x82C9, 0x6A07, 0x934B, 0xB44E, 0x938C, 0x934A, 0xAC0C, 0xBC4D, 0xC4AE, 0xDD51, 0xEE54, // 0x0730 (1840)
0xF676, 0xEDD3, 0xF614, 0xED32, 0xD38C, 0xCB0B, 0xCAEB, 0xCAEA, 0xCACA, 0xCACA, 0xCACA, 0xCACA, 0xCACA, 0xCAEB, 0xCAEB, 0xCACB, // 0x0740 (1856)
0xCAE9, 0xCAEA, 0xCB0A, 0xCB0A, 0xCB0A, 0xCB2A, 0xB32A, 0x7206, 0x7247, 0x61A5, 0x82E9, 0xAC0C, 0xAC4D, 0xA3CB, 0x9BAB, 0xBC4D, // 0x0750 (1872)
0xD4EF, 0xE592, 0xEDF3, 0xEE14, 0xE5F4, 0xEE35, 0xEDF4, 0xEE55, 0xF6B8, 0xF6B7, 0xF676, 0xEE14, 0xEDD3, 0xEDF4, 0xE572, 0xCCB0, // 0x0760 (1888)
0xC44E, 0xD510, 0xE592, 0xE592, 0xDD51, 0xDD51, 0xCCD0, 0xB40D, 0xBC6F, 0xB46F, 0x9BAB, 0xAC0C, 0xBC4D, 0xC4CF, 0xDD71, 0xE5F3, // 0x0770 (1904)
0xFED8, 0xEDB2, 0xED72, 0xE4B0, 0xD34B, 0xCB0B, 0xCAEB, 0xCAEA, 0xCAEA, 0xCAEA, 0xCACA, 0xCACA, 0xCAEB, 0xCAEB, 0xCACB, 0xCAEB, // 0x0780 (1920)
0xC2C9, 0xCAE9, 0xCB0A, 0xCB09, 0xCB09, 0xCB4A, 0xC3AB, 0x8267, 0x7247, 0x69E6, 0x6164, 0x9B4A, 0xBCAF, 0xB42C, 0xABEC, 0xBC6E, // 0x0790 (1936)
0xDD51, 0xEDF3, 0xF676, 0xFEB7, 0xFEF8, 0xFED8, 0xFED8, 0xFEF8, 0xFEF8, 0xFEB7, 0xF656, 0xEDD3, 0xE571, 0xEDF4, 0xEDB3, 0xD511, // 0x07A0 (1952)
0xBC2D, 0xCCCF, 0xE551, 0xE5B3, 0xEDD3, 0xE5B2, 0xE572, 0xD510, 0xCD11, 0xCD73, 0xA3CC, 0xA3AB, 0xB40C, 0xC4CE, 0xE5F3, 0xEE34, // 0x07B0 (1968)
0xF696, 0xE530, 0xE4AF, 0xD3CD, 0xCB0B, 0xCB0B, 0xCAEB, 0xCAEB, 0xCAEA, 0xCAEB, 0xCACA, 0xCAEB, 0xCAEB, 0xCAEB, 0xCAEB, 0xCAEB, // 0x07C0 (1984)
0xC2C9, 0xC2E9, 0xC2E9, 0xC2E9, 0xCB09, 0xCB4A, 0xBB6A, 0x8AC8, 0x82C8, 0x7226, 0x6984, 0x8247, 0xB44D, 0xBC6E, 0xB42D, 0xBC6E, // 0x07D0 (2000)
0xD530, 0xE5B3, 0xF675, 0xFEB7, 0xFEF8, 0xFEF8, 0xFEF8, 0xFEF7, 0xFEF8, 0xFEB7, 0xF634, 0xE551, 0xDD31, 0xF677, 0xF656, 0xD4F0, // 0x07E0 (2016)
0xBC6F, 0xCC8F, 0xE551, 0xE572, 0xED92, 0xE571, 0xDD31, 0xD4F0, 0xD552, 0xD593, 0xA3AB, 0xA38A, 0xB42D, 0xC4EF, 0xE614, 0xEE34, // 0x07F0 (2032)
0xE5B2, 0xDCAF, 0xD3ED, 0xCB2B, 0xCB0B, 0xCB0B, 0xCAEB, 0xCAEA, 0xCAEA, 0xCAEA, 0xCAEB, 0xCAEB, 0xCAEB, 0xCAEB, 0xCAEB, 0xCACB, // 0x0800 (2048)
0xC2E9, 0xCAE9, 0xCB09, 0xCB09, 0xCB2A, 0xB309, 0xBB8B, 0x82A8, 0x82C8, 0x82E8, 0x8267, 0xAB6A, 0xCCAE, 0xB3EC, 0xABCC, 0xB42D, // 0x0810 (2064)
0xCCAF, 0xDD51, 0xEDF3, 0xF655, 0xFEB7, 0xFEF8, 0xFF39, 0xFF19, 0xFEF8, 0xF696, 0xE5B2, 0xD4CF, 0xBBEC, 0xC42D, 0xBC2D, 0x8AA8, // 0x0820 (2080)
0x8AEA, 0xA3AC, 0xE551, 0xEDB2, 0xEDB2, 0xE572, 0xDCF0, 0xD4F0, 0xDDD4, 0xCD32, 0xA36B, 0xA3AB, 0xB42D, 0xCD30, 0xDD92, 0xE5F3, // 0x0830 (2096)
0xDD10, 0xD3CC, 0xD34B, 0xCB0B, 0xCB0B, 0xCB0B, 0xCB0B, 0xCAEB, 0xCAEA, 0xCAEB, 0xCAEB, 0xCAEB, 0xCAEB, 0xCAEB, 0xCAEB, 0xCAEB, // 0x0840 (2112)
0xCB09, 0xCB09, 0xCB09, 0xC309, 0xBAE9, 0xB2E9, 0xB36A, 0x7A46, 0x8287, 0x8AC8, 0xABCB, 0xC44D, 0xDD2F, 0xAB6A, 0xA36A, 0xABAB, // 0x0850 (2128)
0xB40D, 0xD4CF, 0xE571, 0xEDF3, 0xF655, 0xFEF8, 0xFF7B, 0xFF3A, 0xFED7, 0xF655, 0xDD10, 0xB38B, 0x7A06, 0x92C8, 0x71E6, 0x5103, // 0x0860 (2144)
0x5103, 0x71E6, 0xD4CF, 0xEDD3, 0xEDF4, 0xE592, 0xDCD0, 0xD4F0, 0xE636, 0xB46F, 0x8AA8, 0x9329, 0xBC8E, 0xDDD3, 0xDD92, 0xE5B2, // 0x0870 (2160)
0xE531, 0xD3CC, 0xCB2B, 0xCB0B, 0xCB0B, 0xCB0B, 0xCAEB, 0xCAEB, 0xCAEA, 0xCAEB, 0xCB0B, 0xCAEB, 0xCB0B, 0xCAEB, 0xCAEB, 0xCAEB, // 0x0880 (2176)
0xCB09, 0xCB0A, 0xCB0A, 0xCB09, 0xC2E9, 0x9A46, 0x8266, 0x71E5, 0x82A7, 0xABEB, 0xD551, 0xD550, 0xD4EE, 0xBBCB, 0xBC0C, 0xA34A, // 0x0890 (2192)
0xA34A, 0xBC0C, 0xD4CF, 0xE530, 0xEDB2, 0xF696, 0xFF19, 0xFEF8, 0xF655, 0xF634, 0xE5B3, 0xC46E, 0xDD10, 0xD4D0, 0x9B2A, 0x8247, // 0x08A0 (2208)
0x69A5, 0x7A27, 0xCC8E, 0xEDD3, 0xEDF4, 0xE571, 0xD48E, 0xCCAF, 0xD593, 0xA3AC, 0x8227, 0x8247, 0xAC0D, 0xC4CF, 0xCCEF, 0xDD30, // 0x08B0 (2224)
0xE551, 0xD3ED, 0xCB2B, 0xCB2B, 0xCB0B, 0xCB0B, 0xCB0B, 0xCAEB, 0xCAEB, 0xCAEB, 0xCB0B, 0xCB0B, 0xCB0B, 0xCAEB, 0xCAEB, 0xCAEB, // 0x08C0 (2240)
0xCB09, 0xCB0A, 0xCB2A, 0xCB2A, 0xCB2A, 0x9A67, 0x6184, 0x7226, 0x8AC8, 0xABEB, 0xD571, 0xD571, 0xC46D, 0xD50F, 0xCC8E, 0xA34A, // 0x08D0 (2256)
0x92E9, 0xAB8B, 0xC42C, 0xD4AE, 0xE530, 0xEDD3, 0xF675, 0xF675, 0xEE14, 0xF655, 0xF635, 0xF635, 0xF635, 0xEE14, 0xEDB3, 0xDD30, // 0x08E0 (2272)
0xC46E, 0xC46E, 0xCCAF, 0xE551, 0xE592, 0xD4F0, 0xC40D, 0xB3EC, 0xBC8F, 0x9B6B, 0x7A07, 0x7A06, 0x9309, 0xB40C, 0xCCAE, 0xDD31, // 0x08F0 (2288)
0xE531, 0xD3AC, 0xCB2B, 0xCB2B, 0xCB2B, 0xCB2B, 0xCB0B, 0xCAEB, 0xCAEA, 0xCAEB, 0xCB0B, 0xCB0B, 0xCB0B, 0xCAEB, 0xCAEB, 0xCAEB, // 0x0900 (2304)
0xCB0A, 0xCB0A, 0xCB2A, 0xCB2A, 0xCB2A, 0xB2C8, 0x8206, 0x8B29, 0x934A, 0xB48E, 0xCD30, 0xC4EE, 0xBC4C, 0xD4EF, 0xDD71, 0xB3CB, // 0x0910 (2320)
0x8AE9, 0x9B09, 0xB3CB, 0xC42C, 0xD4AE, 0xE550, 0xEDD2, 0xEE13, 0xEE14, 0xF635, 0xEE14, 0xED92, 0xEE14, 0xE551, 0xDCF0, 0xD44D, // 0x0920 (2336)
0xB32A, 0xBBAB, 0xBC2D, 0xCC8E, 0xD4CF, 0xC42D, 0xB3AB, 0x9B4A, 0xA3CC, 0x9B4B, 0x71C6, 0x61A5, 0x8AC8, 0xABEC, 0xCCCF, 0xE571, // 0x0930 (2352)
0xDCAF, 0xD36C, 0xCB2B, 0xCB2B, 0xCB2B, 0xCB2B, 0xCB0B, 0xCB0B, 0xCAEA, 0xCB0B, 0xCB0B, 0xCB0B, 0xCB0B, 0xCB0B, 0xCB0B, 0xCAEB, // 0x0940 (2368)
0xCB0A, 0xCB0A, 0xCB2A, 0xCB2A, 0xCB4A, 0xCB4A, 0xBB09, 0x9AC8, 0x7A88, 0xA40C, 0xBCEF, 0xB44D, 0xABCA, 0xC44D, 0xDD30, 0xBC2C, // 0x0950 (2384)
0x9309, 0x9B2A, 0xB3AB, 0xC40C, 0xD48D, 0xDD2F, 0xE591, 0xEDD2, 0xEDF3, 0xDD51, 0xB2E9, 0xAA26, 0xAA87, 0xA226, 0x99C5, 0x9184, // 0x0960 (2400)
0x78C1, 0x70C1, 0x81E5, 0xABAB, 0xD4AF, 0xC44D, 0xAB8B, 0x930A, 0xA3CC, 0x8AEA, 0x4104, 0x5165, 0x92E9, 0xA38A, 0xBC0C, 0xCC6E, // 0x0970 (2416)
0xCB6C, 0xCB2B, 0xCB2B, 0xD34C, 0xD34B, 0xCB2B, 0xCB2B, 0xCB0B, 0xCB0B, 0xCB0B, 0xCB0B, 0xCB0B, 0xCB0B, 0xCB0B, 0xCB0B, 0xCAEB, // 0x0980 (2432)
0xCB2A, 0xCB2A, 0xCB2A, 0xCB2A, 0xCB4A, 0xCB6A, 0xD38B, 0xC329, 0x79A5, 0x69E5, 0x7AC8, 0x8B08, 0x9308, 0xAB69, 0xB40C, 0xAC0C, // 0x0990 (2448)
0x9B8B, 0x9B4A, 0xB3AB, 0xBC0B, 0xCC8D, 0xDD0F, 0xE571, 0xE571, 0xDD30, 0x9A05, 0x80E1, 0x9A47, 0xC490, 0xD594, 0xCD11, 0xBC8F, // 0x09A0 (2464)
0x8A67, 0x60C2, 0x5860, 0x9288, 0xCC8E, 0xC46D, 0xABAB, 0x934B, 0xAC0D, 0x6AA9, 0x3125, 0x4986, 0x7268, 0x9B2A, 0xB3CB, 0xD46E, // 0x09B0 (2480)
0xCB4B, 0xCB2B, 0xD34B, 0xD34C, 0xD34C, 0xD32B, 0xCB2B, 0xCB2B, 0xCB0B, 0xCB0B, 0xCB0B, 0xCB0B, 0xCB2B, 0xCB0B, 0xCB0B, 0xCB0B, // 0x09C0 (2496)
0xCB2A, 0xCB2A, 0xCB2A, 0xCB4A, 0xCB4A, 0xD36B, 0xCB6B, 0xBAE9, 0x81A5, 0x50E2, 0x5984, 0x5984, 0x6184, 0x8AC8, 0x7288, 0x41E7, // 0x09D0 (2512)
0x8B09, 0x934A, 0xABAB, 0xBC0C, 0xCC8D, 0xDD0F, 0xE571, 0xDD50, 0xC42C, 0x60A1, 0x6123, 0xA38C, 0xC4F1, 0xCD52, 0xCD52, 0xB44E, // 0x09E0 (2528)
0x8AE9, 0x6185, 0x58C2, 0xB36A, 0xCCAE, 0xC46E, 0xABCC, 0xA3AC, 0xAC4E, 0x4985, 0x28C4, 0x3105, 0x7ACA, 0xA36A, 0xB3AB, 0xD40D, // 0x09F0 (2544)
0xCB4B, 0xCB2B, 0xD34C, 0xD34C, 0xD34C, 0xD34B, 0xD32B, 0xCB2B, 0xCB0B, 0xCB0B, 0xCB0B, 0xCB0B, 0xD32B, 0xCB2B, 0xCB0B, 0xCB0B, // 0x0A00 (2560)
0xCB4A, 0xCB4A, 0xCB4A, 0xCB4A, 0xCB4A, 0xD36A, 0xD36A, 0x8A06, 0x5923, 0x48E3, 0x5164, 0x5984, 0x5984, 0x49C6, 0x3965, 0x39C7, // 0x0A10 (2576)
0x59E6, 0x832A, 0xABAB, 0xBC0C, 0xCC8E, 0xDD30, 0xE591, 0xEDD2, 0xE591, 0xA267, 0x9AA8, 0xCC8F, 0xD532, 0xDDB4, 0xD594, 0xBBEC, // 0x0A20 (2592)
0x9206, 0x70E3, 0x91E5, 0xC44D, 0xCCAE, 0xC44D, 0xB3EC, 0xABEC, 0xB44E, 0x4186, 0x3146, 0x30C4, 0x8B2B, 0xB3CC, 0xCBCC, 0xD3AC, // 0x0A30 (2608)
0xD34B, 0xD34B, 0xD34C, 0xD36C, 0xD34C, 0xD34B, 0xCB2B, 0xD32B, 0xCB2B, 0xCB0B, 0xCB0B, 0xCB2B, 0xD32B, 0xD32B, 0xCB0B, 0xCB0B, // 0x0A40 (2624)
0xCB4A, 0xCB4A, 0xD36A, 0xCB4A, 0xCB4A, 0xCB6A, 0xCB6A, 0x79C5, 0x69C5, 0x7267, 0x61C5, 0x61A5, 0x5143, 0x2061, 0x3145, 0x20C3, // 0x0A50 (2640)
0x2125, 0x6ACA, 0xA38B, 0xBC0C, 0xCC6D, 0xDD0F, 0xE591, 0xEDF3, 0xEE13, 0xDCF0, 0xAA46, 0xAA26, 0xC36B, 0xC36B, 0xBB09, 0xA1C5, // 0x0A60 (2656)
0x88E2, 0x8984, 0xAB6A, 0xC44D, 0xC44D, 0xBC2D, 0xABED, 0xAC0D, 0x9BCD, 0x2041, 0x3925, 0x6228, 0xA36B, 0xCBAC, 0xD38C, 0xCB4B, // 0x0A70 (2672)
0xCB4B, 0xD34B, 0xD34C, 0xD36C, 0xD34C, 0xD34C, 0xD34C, 0xD34B, 0xD32B, 0xCB2B, 0xCB2B, 0xD32B, 0xD34B, 0xD32B, 0xD32B, 0xD32B, // 0x0A80 (2688)
0xCB4A, 0xCB4A, 0xD36A, 0xCB4A, 0xCB4A, 0xCB6A, 0xCB4A, 0x7184, 0x61A4, 0x7AA7, 0x6A26, 0x4902, 0x3061, 0x2925, 0x4208, 0x4A8A, // 0x0A90 (2704)
0x20E4, 0x4165, 0x8309, 0xABCB, 0xC44D, 0xD4CE, 0xDD50, 0xE5D2, 0xEE13, 0xEE14, 0xDCCF, 0xB2C8, 0xA1E5, 0xA226, 0xA1E5, 0x8984, // 0x0AA0 (2720)
0x9226, 0xAB4A, 0xBC0D, 0xBC0C, 0xBC0C, 0xB3EC, 0xABCC, 0xAC2D, 0x82EA, 0x4924, 0x5186, 0xAB6B, 0xCB8C, 0xCB6B, 0xD36B, 0xCB4B, // 0x0AB0 (2736)
0xCB4B, 0xD34C, 0xD36C, 0xD36C, 0xD36C, 0xD36C, 0xD34C, 0xD34B, 0xCB2B, 0xD32B, 0xD34B, 0xD36C, 0xD36C, 0xD36C, 0xD34B, 0xD34C, // 0x0AC0 (2752)
0xCB2A, 0xCB2A, 0xCB4A, 0xCB4A, 0xCB4A, 0xCB6A, 0xCB4A, 0x7143, 0x6184, 0x8B49, 0x938B, 0x8309, 0x40E2, 0x3082, 0x28E3, 0x41E8, // 0x0AD0 (2768)
0x28E4, 0x30C2, 0x6A67, 0x936A, 0xB40C, 0xC46D, 0xD50F, 0xE591, 0xEDF3, 0xF634, 0xEE14, 0xEDD3, 0xE551, 0xDCF0, 0xD4AF, 0xD4AF, // 0x0AE0 (2784)
0xCC8E, 0xCC6E, 0xC46E, 0xBC2D, 0xB3EC, 0xA3AB, 0xA38B, 0xA3EC, 0xA3CC, 0x7A68, 0xA36B, 0xCBCC, 0xCB6C, 0xD36B, 0xD36B, 0xD34B, // 0x0AF0 (2800)
0xD34B, 0xD34C, 0xD36C, 0xD36C, 0xD38C, 0xDBEE, 0xE4B1, 0xE4D1, 0xDC6F, 0xDC6F, 0xE4B0, 0xE511, 0xED31, 0xE4F0, 0xE48F, 0xDC2E, // 0x0B00 (2816)
0xCB2A, 0xCB2A, 0xCB4A, 0xCB4A, 0xCB4A, 0xCB6A, 0xCB6A, 0xAA87, 0x7184, 0x7226, 0x8B49, 0x936A, 0x7287, 0x48E2, 0x4144, 0x4164, // 0x0B10 (2832)
0x2861, 0x30C3, 0x7267, 0x7AC9, 0x934A, 0xBC4D, 0xCCCE, 0xDD30, 0xE5B2, 0xEE14, 0xF655, 0xF655, 0xF676, 0xF676, 0xF614, 0xEDB3, // 0x0B20 (2848)
0xDD10, 0xD4F0, 0xCC8E, 0xBC2D, 0xA3AB, 0x9B6B, 0x9B6B, 0x8B0A, 0xA3CC, 0x8B6B, 0x9B8C, 0xB3AD, 0xCBAC, 0xCB6B, 0xD36B, 0xD34B, // 0x0B30 (2864)
0xD36C, 0xD3AC, 0xDC0E, 0xE4D1, 0xEE16, 0xF6FA, 0xF6B8, 0xF6B7, 0xFEB7, 0xFEB7, 0xFED8, 0xFED8, 0xFED8, 0xFE96, 0xF614, 0xED92, // 0x0B40 (2880)
0xCB2A, 0xCB2A, 0xCB2A, 0xCB4A, 0xCB4A, 0xCB6A, 0xCB6A, 0xB2C8, 0x71A5, 0x71E6, 0x8287, 0x82E8, 0x7AA7, 0x7267, 0x8309, 0x51A4, // 0x0B50 (2896)
0x38A1, 0x3881, 0x7AA8, 0x8B29, 0x6A47, 0x9B6A, 0xBC4C, 0xCCCE, 0xDD51, 0xEDD3, 0xF635, 0xF696, 0xFED8, 0xFEF9, 0xF655, 0xEDB3, // 0x0B60 (2912)
0xDCF0, 0xD4EF, 0xC46E, 0xABEC, 0x9B6B, 0x8B2A, 0x7A68, 0x6A27, 0x936B, 0x8B6C, 0x834C, 0x7B2B, 0x9BED, 0xB3CD, 0xB34B, 0xB36C, // 0x0B70 (2928)
0xC46F, 0xE5B5, 0xF71B, 0xFFDE, 0xFFDF, 0xF71A, 0xFF39, 0xFF3A, 0xFF3A, 0xFF39, 0xFF3A, 0xFF5A, 0xFF3A, 0xFF19, 0xFE97, 0xF634, // 0x0B80 (2944)
0xCB2A, 0xCB2A, 0xCB4A, 0xCB4A, 0xCB6A, 0xD38B, 0xD38B, 0xC329, 0x81E5, 0x7226, 0x8B09, 0x8B08, 0x8AE8, 0x936A, 0x7AE9, 0x6A67, // 0x0B90 (2960)
0x6206, 0x4103, 0x7AC9, 0xAC0C, 0x82C8, 0x59E6, 0x82E9, 0xABEC, 0xC48E, 0xDD50, 0xEDD3, 0xF655, 0xF696, 0xEE55, 0xE5D3, 0xEDD3, // 0x0BA0 (2976)
0xDD30, 0xCC8E, 0xABCC, 0x934A, 0x82C9, 0x6A07, 0x5965, 0x5985, 0x6A07, 0x7B4B, 0x838D, 0x7B4C, 0x8BCD, 0x9C4F, 0xACB0, 0xAC90, // 0x0BB0 (2992)
0xD636, 0xF75C, 0xFFDF, 0xFFFF, 0xF73B, 0xFF5A, 0xFF7B, 0xFF5A, 0xFF5A, 0xFF5A, 0xFF7B, 0xFF7B, 0xFF7B, 0xFF5A, 0xFF18, 0xFE96, // 0x0BC0 (3008)
0xCB4A, 0xCB4A, 0xCB4A, 0xD36A, 0xD36B, 0xD38B, 0xD3AB, 0xCB8B, 0x89E5, 0x5943, 0x7267, 0x8B09, 0x8B29, 0x8B6A, 0x8309, 0x9BEC, // 0x0BD0 (3024)
0x834A, 0x51C5, 0x6A88, 0xAC2D, 0xAC0C, 0x6A27, 0x4923, 0x6227, 0x934A, 0xB40D, 0xCCCF, 0xD551, 0xD551, 0xD510, 0xCCAF, 0xCCF0, // 0x0BE0 (3040)
0xB40D, 0x932A, 0x82C9, 0x7A88, 0x61E6, 0x5964, 0x5944, 0x5144, 0x5144, 0x49C6, 0x6289, 0x6ACA, 0x83AD, 0xBD74, 0xE6B9, 0xDE99, // 0x0BF0 (3056)
0xEF1B, 0xFFDE, 0xFFFF, 0xFFDF, 0xF71A, 0xFF7B, 0xFF7B, 0xFF5A, 0xFF5A, 0xFF7B, 0xFF7B, 0xFF9B, 0xFF9B, 0xFF7B, 0xFF3A, 0xFED7, // 0x0C00 (3072)
0xCB4A, 0xCB4A, 0xD36A, 0xD36B, 0xD36A, 0xD38B, 0xD3AB, 0xD3AB, 0xAA67, 0x50E2, 0x5964, 0x69E5, 0x7AC8, 0x834A, 0xA44D, 0xB4F0, // 0x0C10 (3088)
0xC5B3, 0xA4B0, 0x8BAC, 0xAC2D, 0xC48E, 0xB42D, 0x7AA8, 0x4103, 0x4123, 0x6227, 0x7AA9, 0x8B2A, 0x8B09, 0x82A8, 0x7247, 0x7227, // 0x0C20 (3104)
0x69E6, 0x6A06, 0x61C6, 0x5985, 0x5144, 0x5144, 0x5124, 0x5103, 0x48E3, 0x2041, 0x1800, 0x1800, 0x1820, 0x3124, 0x83CF, 0xBDF7, // 0x0C30 (3120)
0xF77D, 0xFFDF, 0xFFFF, 0xF79D, 0xEED8, 0xFF9C, 0xFF9C, 0xFF7B, 0xFF7B, 0xFF7B, 0xFF7B, 0xFF9C, 0xFF9C, 0xFF9B, 0xFF3A, 0xFEF8, // 0x0C40 (3136)
0xCB4A, 0xD34B, 0xD36B, 0xD38B, 0xD36B, 0xD38B, 0xD3AB, 0xD38B, 0xB2C9, 0x7985, 0x71A5, 0x8267, 0x8B09, 0x8B4A, 0xBD10, 0xDE97, // 0x0C50 (3152)
0xEF3B, 0xEF3B, 0xDE98, 0xBCF0, 0xC4AE, 0xC4CF, 0xB44D, 0x82A8, 0x5184, 0x4103, 0x4124, 0x4964, 0x5165, 0x5164, 0x5164, 0x5964, // 0x0C60 (3168)
0x5964, 0x5944, 0x5144, 0x5124, 0x5124, 0x5144, 0x5124, 0x5103, 0x40C3, 0x2041, 0x1800, 0x1800, 0x1821, 0x1842, 0x2083, 0x3146, // 0x0C70 (3184)
0x738E, 0xCE59, 0xF7BF, 0xE6B9, 0xEEB8, 0xFF9C, 0xFF9C, 0xFF7B, 0xFF7B, 0xFF7A, 0xFF7B, 0xFF9C, 0xFF9C, 0xFF7B, 0xFF39, 0xFED8, // 0x0C80 (3200)
0xCB4A, 0xD34A, 0xD36B, 0xD36B, 0xCB6B, 0xD38B, 0xD3AB, 0xD38B, 0xC34A, 0x91E6, 0x8A26, 0x9AE9, 0x9B4A, 0x9BCB, 0xDE77, 0xEF1A, // 0x0C90 (3216)
0xF79D, 0xFFDE, 0xFFBE, 0xD615, 0xBCCE, 0xCCEF, 0xCD10, 0xC4AE, 0x9B8B, 0x6206, 0x4964, 0x4124, 0x4924, 0x4923, 0x5144, 0x5144, // 0x0CA0 (3232)
0x5124, 0x5944, 0x5944, 0x5124, 0x5124, 0x5144, 0x5944, 0x5124, 0x48E3, 0x2841, 0x1800, 0x1800, 0x1821, 0x1863, 0x1883, 0x1884, // 0x0CB0 (3248)
0x20A4, 0x2925, 0x736E, 0xA42E, 0xF6F9, 0xFF7C, 0xFF9C, 0xFF9C, 0xFF7B, 0xFF7B, 0xFF7B, 0xFF9B, 0xFF9B, 0xFF7B, 0xFF19, 0xFED7, // 0x0CC0 (3264)
0xCB4A, 0xCB4B, 0xD36B, 0xD36B, 0xD36B, 0xD38B, 0xD3AB, 0xD3AC, 0xD3AB, 0xC34A, 0xB2E9, 0xBB4A, 0xC3EC, 0xDE36, 0xFFBE, 0xFFBE, // 0x0CD0 (3280)
0xFFBE, 0xFFFF, 0xFFDE, 0xEF1A, 0xC510, 0xCD0F, 0xCD30, 0xD550, 0xC4CF, 0x9BAB, 0x7267, 0x5185, 0x4944, 0x4944, 0x5144, 0x5144, // 0x0CE0 (3296)
0x5944, 0x5964, 0x5964, 0x5124, 0x5124, 0x5964, 0x5964, 0x5144, 0x4903, 0x3082, 0x1820, 0x1821, 0x1862, 0x1883, 0x1884, 0x1884, // 0x0CF0 (3312)
0x1883, 0x2084, 0x20C4, 0x6269, 0xEE97, 0xFF5B, 0xFF7B, 0xFF9C, 0xFF9C, 0xFF7B, 0xFF7B, 0xFF7B, 0xFF7B, 0xFF5A, 0xFF19, 0xF6B6, // 0x0D00 (3328)
0xD36B, 0xD36B, 0xD36B, 0xD38B, 0xD38B, 0xD3AB, 0xD3AB, 0xD3AB, 0xD3AC, 0xD3CC, 0xD3CC, 0xD40D, 0xE5D5, 0xFFBE, 0xFFFF, 0xFFFF, // 0x0D10 (3344)
0xFFFF, 0xFFFF, 0xFFDE, 0xF79D, 0xD5D4, 0xC510, 0xCD30, 0xD571, 0xD571, 0xCCEF, 0xA3EC, 0x7AA8, 0x59A5, 0x5164, 0x5164, 0x5164, // 0x0D20 (3360)
0x5965, 0x5964, 0x5964, 0x5944, 0x5944, 0x5965, 0x5985, 0x5164, 0x5144, 0x4904, 0x4924, 0x30C3, 0x20A4, 0x20A4, 0x2084, 0x2084, // 0x0D30 (3376)
0x1884, 0x1884, 0x1883, 0x28E4, 0x732C, 0xDE57, 0xFF5A, 0xFF7B, 0xFF9B, 0xFF7B, 0xFF7B, 0xFF7B, 0xFF5B, 0xFF3A, 0xFEF8, 0xF675, // 0x0D40 (3392)
0xD36B, 0xD36B, 0xD38B, 0xD38B, 0xD38B, 0xD3AB, 0xD3AB, 0xD3AC, 0xD3CC, 0xD3CC, 0xD3ED, 0xDCB0, 0xF75C, 0xFFFF, 0xFFFF, 0xFFFF, // 0x0D50 (3408)
0xFFFF, 0xFFFF, 0xFFFF, 0xF79D, 0xDE77, 0xC510, 0xCD30, 0xD551, 0xD551, 0xD550, 0xC4CF, 0xABEC, 0x82C8, 0x61E6, 0x5985, 0x5985, // 0x0D60 (3424)
0x5985, 0x5985, 0x5965, 0x5964, 0x5985, 0x5985, 0x5985, 0x5985, 0x5965, 0x69E6, 0x934A, 0x936B, 0x3946, 0x28C5, 0x20A4, 0x2084, // 0x0D70 (3440)
0x1884, 0x1884, 0x1883, 0x1884, 0x20C4, 0x49E8, 0xACF2, 0xEEF9, 0xFF5B, 0xFF5A, 0xFF5A, 0xFF7B, 0xFF3A, 0xFF18, 0xF6B6, 0xEE34, // 0x0D80 (3456)
0xD36B, 0xD38B, 0xD38B, 0xD38B, 0xD38B, 0xD38B, 0xD3AC, 0xD3CC, 0xD3CC, 0xD3CC, 0xDC0D, 0xE4F1, 0xFF9D, 0xFFDF, 0xFFFF, 0xFFFF, // 0x0D90 (3472)
0xFFFF, 0xFFFF, 0xFFFF, 0xFFDE, 0xEF1A, 0xC530, 0xC50F, 0xD550, 0xD550, 0xD550, 0xCD30, 0xC4AE, 0xABEC, 0x8AE9, 0x7227, 0x69E6, // 0x0DA0 (3488)
0x61A5, 0x61A5, 0x61A5, 0x5985, 0x5985, 0x61A5, 0x61A5, 0x61C6, 0x61E6, 0x9309, 0xBC4D, 0xD510, 0x8B8C, 0x3105, 0x20C5, 0x20A4, // 0x0DB0 (3504)
0x2084, 0x1883, 0x1884, 0x1884, 0x1863, 0x20A4, 0x2905, 0x7B8D, 0xDE77, 0xFF39, 0xFF3A, 0xFF3A, 0xFF19, 0xFED7, 0xF696, 0xEE34, // 0x0DC0 (3520)
0xD36B, 0xD38B, 0xD3AB, 0xD38B, 0xD38B, 0xD3AB, 0xD3AC, 0xD3CC, 0xD3CC, 0xD3EC, 0xDC0D, 0xDC6E, 0xF6D9, 0xF79D, 0xFFDF, 0xFFFF, // 0x0DD0 (3536)
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xF79D, 0xBCEF, 0xBCCE, 0xCD30, 0xD571, 0xD571, 0xCD50, 0xCD10, 0xC4AE, 0xB42C, 0x9B4A, 0x82C8, // 0x0DE0 (3552)
0x7247, 0x6A06, 0x69E6, 0x61C6, 0x61A5, 0x61C5, 0x69E6, 0x7227, 0x82C8, 0xB40C, 0xCCEF, 0xDD92, 0xDD92, 0x832B, 0x28E5, 0x20A4, // 0x0DF0 (3568)
0x20A4, 0x1884, 0x1884, 0x1884, 0x1884, 0x1863, 0x18A4, 0x20C4, 0x41A7, 0xB512, 0xEEB7, 0xF6F8, 0xFEF8, 0xF6B7, 0xF675, 0xEE34, // 0x0E00 (3584)
0xCB6B, 0xD38B, 0xD3AB, 0xD3AB, 0xD38B, 0xD3AB, 0xD3CB, 0xD3CC, 0xD3CC, 0xD3EC, 0xD40D, 0xDC4D, 0xE572, 0xEF1A, 0xF79D, 0xFFDF, // 0x0E10 (3600)
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFDF, 0xC551, 0xB46D, 0xC50F, 0xCD70, 0xD571, 0xD550, 0xCD10, 0xCCEF, 0xC4CE, 0xB44D, 0xA3AB, // 0x0E20 (3616)
0x8B09, 0x82A8, 0x7A67, 0x7227, 0x6A06, 0x6A27, 0x7A88, 0x8AE9, 0xA3AB, 0xC4AE, 0xD551, 0xE5D3, 0xE614, 0xCD72, 0x41A7, 0x28E5, // 0x0E30 (3632)
0x20C5, 0x18A4, 0x1884, 0x18A4, 0x1884, 0x1863, 0x1883, 0x1884, 0x18A4, 0x3146, 0x940F, 0xEEB7, 0xF6D7, 0xF6B6, 0xEE75, 0xEE34, // 0x0E40 (3648)
0xCB6A, 0xD38B, 0xD38B, 0xD38B, 0xD38B, 0xD3AB, 0xD3CB, 0xD3CC, 0xD3EC, 0xD40C, 0xDC2D, 0xDC4E, 0xDC8E, 0xE615, 0xEF5B, 0xF7BE, // 0x0E50 (3664)
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xEF1A, 0xB48E, 0xBCAE, 0xCD30, 0xD571, 0xD571, 0xCD50, 0xCD2F, 0xCD0F, 0xC4CE, 0xBC6D, // 0x0E60 (3680)
0xA3EB, 0x9B6A, 0x9329, 0x8B09, 0x8B09, 0x936A, 0xA3CC, 0xB44D, 0xC4CE, 0xD550, 0xDDB2, 0xE613, 0xEE34, 0xEE55, 0xAC8F, 0x4187, // 0x0E70 (3696)
0x2905, 0x20C4, 0x18A4, 0x18A4, 0x18A4, 0x18A4, 0x1884, 0x1083, 0x1883, 0x18A4, 0x20E5, 0x6B0B, 0xD5D4, 0xEE75, 0xEE54, 0xE614, // 0x0E80 (3712)
0xCB6A, 0xD36B, 0xD38B, 0xD38B, 0xD38B, 0xD3AB, 0xD3CB, 0xD3CC, 0xD3EC, 0xDC2D, 0xDC4D, 0xDC6E, 0xDC8E, 0xEDF4, 0xEF7C, 0xF7BD, // 0x0E90 (3728)
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFDF, 0xCDF5, 0xAC6D, 0xC50F, 0xCD70, 0xD571, 0xD571, 0xD550, 0xD550, 0xCD0F, 0xC4EE, // 0x0EA0 (3744)
0xBC6D, 0xB42C, 0xAC0C, 0xAC0C, 0xB42C, 0xBC8E, 0xC4CF, 0xCD0F, 0xD571, 0xDDD2, 0xE613, 0xEE54, 0xEE55, 0xEE75, 0xE635, 0x9C0E, // 0x0EB0 (3760)
0x3126, 0x20E5, 0x18C4, 0x18C5, 0x18C5, 0x18A4, 0x18A4, 0x18A4, 0x1084, 0x1883, 0x18A4, 0x20C4, 0x5229, 0xACD0, 0xDDF3, 0xE5F3, // 0x0EC0 (3776)
0xCB6B, 0xD36B, 0xD38B, 0xD38B, 0xD38B, 0xD3AB, 0xD3CB, 0xD3EC, 0xD40C, 0xDC2D, 0xDC4D, 0xDC6E, 0xDC8E, 0xEE15, 0xF7BD, 0xF7DE, // 0x0ED0 (3792)
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xF7BE, 0xB4F0, 0xC52F, 0xD570, 0xD591, 0xD591, 0xD570, 0xD570, 0xD570, 0xD550, // 0x0EE0 (3808)
0xCCEF, 0xC4CE, 0xC4AE, 0xC4CF, 0xCD10, 0xD571, 0xDDB2, 0xDDB2, 0xE5F2, 0xEE33, 0xEE54, 0xEE54, 0xEE75, 0xF695, 0xEE96, 0xE655, // 0x0EF0 (3824)
0x5208, 0x2905, 0x20C4, 0x18C4, 0x18C5, 0x18A5, 0x1083, 0x18A4, 0x18A4, 0x10A4, 0x1083, 0x18A4, 0x18C4, 0x2905, 0x8B8C, 0xD591, // 0x0F00 (3840)
0xCB4B, 0xCB6B, 0xD38B, 0xD38A, 0xD38B, 0xD3AB, 0xD3CB, 0xD3CC, 0xD3EC, 0xDC0C, 0xDC2D, 0xDC4D, 0xDC8E, 0xE635, 0xF7BE, 0xF7DE, // 0x0F10 (3856)
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xE6B9, 0xD592, 0xE5F2, 0xE613, 0xE613, 0xDDD2, 0xDDB1, 0xDDB1, 0xDD91, // 0x0F20 (3872)
0xD570, 0xD570, 0xDD71, 0xDDB2, 0xE5F3, 0xE613, 0xEE34, 0xEE33, 0xEE34, 0xEE54, 0xEE54, 0xEE54, 0xF675, 0xF696, 0xF696, 0xEE96, // 0x0F30 (3888)
0xA46F, 0x3166, 0x20E5, 0x18C4, 0x18C5, 0x18A5, 0x1083, 0x18A4, 0x18A4, 0x1084, 0x1084, 0x1083, 0x1083, 0x18A4, 0x20E5, 0x5228, // 0x0F40 (3904)
0xCB4A, 0xCB4A, 0xCB6A, 0xD36A, 0xD38A, 0xD3AB, 0xD3AB, 0xD3CB, 0xD3EC, 0xD40C, 0xDC2D, 0xD46E, 0xD4EF, 0xE677, 0xF7BE, 0xFFFF, // 0x0F50 (3920)
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xF7BE, 0xE655, 0xEE74, 0xF675, 0xEE75, 0xEE54, 0xEE53, 0xE613, 0xE612, // 0x0F60 (3936)
0xE5F2, 0xE5F3, 0xE613, 0xEE34, 0xF675, 0xF695, 0xF675, 0xEE75, 0xF675, 0xEE75, 0xEE75, 0xEE75, 0xF695, 0xF696, 0xF696, 0xF6B6, // 0x0F70 (3952)
0xE635, 0x62CA, 0x2105, 0x18C4, 0x18A4, 0x18A5, 0x10A4, 0x1083, 0x18A4, 0x10A4, 0x1084, 0x1084, 0x1083, 0x1083, 0x1083, 0x1883, // 0x0F80 (3968)
0xCB2A, 0xCB4A, 0xCB6A, 0xCB6A, 0xCB6A, 0xD38B, 0xD3AB, 0xD3CB, 0xD3EC, 0xD42D, 0xD4CE, 0xD571, 0xDE34, 0xF77C, 0xFFDF, 0xFFFF, // 0x0F90 (3984)
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xB594, 0xE654, 0xF6B6, 0xF6D6, 0xF6B6, 0xF695, 0xF695, 0xF695, // 0x0FA0 (4000)
0xEE54, 0xEE54, 0xEE54, 0xF675, 0xF695, 0xF6B5, 0xF695, 0xF695, 0xF695, 0xEE75, 0xEE75, 0xEE75, 0xF695, 0xF696, 0xF6B6, 0xF6B7, // 0x0FB0 (4016)
0xEE96, 0xB4F1, 0x2926, 0x20C5, 0x18A4, 0x18C5, 0x18A5, 0x1083, 0x10A4, 0x10A4, 0x1084, 0x1084, 0x1084, 0x1083, 0x1063, 0x1063, // 0x0FC0 (4032)
0xCB2A, 0xCB4A, 0xCB4A, 0xCB6A, 0xCB6A, 0xD38B, 0xD3AB, 0xD3CB, 0xD44D, 0xD52F, 0xDDD2, 0xE654, 0xF75B, 0xFFDF, 0xFFFF, 0xFFFF, // 0x0FD0 (4048)
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xEF9E, 0x73AE, 0xACAF, 0xF6B6, 0xF6F7, 0xF6B6, 0xF6B6, 0xF6D6, 0xF6B6, // 0x0FE0 (4064)
0xF695, 0xF695, 0xF695, 0xF6B6, 0xF6B6, 0xF6D6, 0xF6D6, 0xF6B6, 0xF695, 0xF675, 0xF675, 0xEE75, 0xEE75, 0xF696, 0xF6B6, 0xF6B6, // 0x0FF0 (4080)
0xEE96, 0xDDF4, 0x4A08, 0x20E5, 0x18A4, 0x18C5, 0x18A5, 0x1083, 0x1084, 0x10A4, 0x10A4, 0x10A4, 0x1084, 0x1063, 0x1063, 0x1043, // 0x1000 (4096)
};
// Generated by : ImageConverter 565 v2.3
// Generated from: tractor10.jpg
// Time generated: 11-May-18 09:27:27
// Dimensions : 96x64 pixels
// Size : 12,288 Bytes
#include <avr/pgmspace.h>
const uint16_t tractor10_96x64[0x1800] PROGMEM ={
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, // 0x0010 (16)
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, // 0x0020 (32)
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, // 0x0030 (48)
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFDF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFDF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, // 0x0040 (64)
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, // 0x0050 (80)
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, // 0x0060 (96)
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, // 0x0070 (112)
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xF7DE, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, // 0x0080 (128)
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, // 0x0090 (144)
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, // 0x00A0 (160)
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, // 0x00B0 (176)
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xF7DE, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, // 0x00C0 (192)
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, // 0x00D0 (208)
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, // 0x00E0 (224)
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, // 0x00F0 (240)
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xF7BE, 0x9C71, 0x838D, 0x7B4C, 0x9410, 0xC5D6, 0xF79E, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, // 0x0100 (256)
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, // 0x0110 (272)
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, // 0x0120 (288)
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, // 0x0130 (304)
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xF7DE, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, // 0x0140 (320)
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, // 0x0150 (336)
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0x9430, 0xA4B2, 0xF77D, 0xACF3, 0xC5D7, 0xB575, 0x942F, 0xC5F7, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, // 0x0160 (352)
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, // 0x0170 (368)
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, // 0x0180 (384)
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, // 0x0190 (400)
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xF7DE, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, // 0x01A0 (416)
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, // 0x01B0 (432)
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0x83AE, 0xEF3C, 0xFFFF, 0xDEDB, 0xCE38, 0xFFFF, 0xEF5C, 0x9C92, 0xAD34, 0xFFFF, 0xFFFF, 0xFFFF, // 0x01C0 (448)
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, // 0x01D0 (464)
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, // 0x01E0 (480)
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, // 0x01F0 (496)
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xF7DE, 0xFFFF, 0xFFFF, 0xFFFF, // 0x0200 (512)
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, // 0x0210 (528)
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xAD34, 0xCE59, 0xFFFF, 0xFFFF, 0xB595, 0xF7BE, 0xFFFF, 0xFFFF, 0xACF3, 0xA4F3, 0xFFFF, 0xFFFF, // 0x0220 (544)
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, // 0x0230 (560)
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, // 0x0240 (576)
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, // 0x0250 (592)
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xF7DE, 0xFFFF, 0xFFFF, // 0x0260 (608)
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFDF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, // 0x0270 (624)
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xEF9E, 0xBD96, 0xFFDF, 0xFFFF, 0xC5B7, 0x83CF, 0xFFFF, 0xFFFF, 0xFFFF, 0x8B8E, 0xCE18, 0xFFFF, // 0x0280 (640)
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, // 0x0290 (656)
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, // 0x02A0 (672)
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, // 0x02B0 (688)
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xF7DE, 0xFFFF, // 0x02C0 (704)
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xEEDA, 0xDE38, 0xEFBE, 0xF77D, 0xF71B, 0xEE99, // 0x02D0 (720)
0xEDD5, 0xE512, 0xE4B0, 0xE42E, 0xDB49, 0xCA25, 0xD3AC, 0xC533, 0x9268, 0x6922, 0xB34B, 0xC574, 0xE75D, 0xD659, 0x8C30, 0xFFFF, // 0x02E0 (736)
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, // 0x02F0 (752)
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, // 0x0300 (768)
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, // 0x0310 (784)
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xF7DE, 0xFFFF, // 0x0320 (800)
0xFFFF, 0xFFFF, 0xFFFF, 0xF7DF, 0xF75D, 0xF6FB, 0xEE38, 0xE553, 0xE4B0, 0xE44E, 0xCA25, 0xB921, 0xD265, 0xDA23, 0xD1E2, 0xD1A1, // 0x0330 (816)
0xD160, 0xD920, 0xD920, 0xD920, 0xE180, 0xE180, 0xE1A0, 0xC161, 0x9901, 0xC982, 0xD940, 0xC900, 0xB2E9, 0xB574, 0x8451, 0xFFFF, // 0x0340 (832)
0xFFFF, 0xFF9E, 0xFF5D, 0xFF5C, 0xFFBE, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, // 0x0350 (848)
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, // 0x0360 (864)
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, // 0x0370 (880)
0xFFFF, 0xFFDF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xF7DF, 0xF77D, 0xF71B, 0xF699, 0xEDF6, 0xE532, // 0x0380 (896)
0xE48F, 0xE3ED, 0xE329, 0xDA85, 0xD9E3, 0xD9C2, 0xD980, 0xD920, 0xD920, 0xD920, 0xE160, 0xE180, 0xE160, 0xE180, 0xE9A0, 0xF1C1, // 0x0390 (912)
0xF243, 0xF264, 0xEA44, 0xF2A6, 0xEA86, 0xD204, 0xCA45, 0xAA04, 0x7142, 0x7963, 0x9163, 0xA961, 0xB141, 0x81E5, 0x9C30, 0xED93, // 0x03A0 (928)
0xE40D, 0xD286, 0xD1E3, 0xD9E3, 0xD245, 0xCBAC, 0xEEBA, 0xFFFF, 0xFFDF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFF9D, 0xFF7D, 0xFFFF, // 0x03B0 (944)
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, // 0x03C0 (960)
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, // 0x03D0 (976)
0xFFFF, 0xFFFF, 0xFFFF, 0xF77C, 0xF71B, 0xEE78, 0xEDD5, 0xECF1, 0xE44F, 0xE3AB, 0xDAE7, 0xDA44, 0xE204, 0xE1C2, 0xE160, 0xE120, // 0x03E0 (992)
0xE140, 0xE160, 0xE160, 0xE160, 0xE160, 0xE980, 0xE981, 0xE1A1, 0xE9C2, 0xEA03, 0xEA65, 0xF2A6, 0xEAA5, 0xEAE8, 0xE2C7, 0xD265, // 0x03F0 (1008)
0xCA86, 0xBA45, 0xA1C3, 0x91A4, 0x8983, 0x6922, 0x6902, 0x7122, 0x7942, 0x7963, 0x7164, 0x5944, 0x5943, 0x8122, 0xD1A1, 0xE1A1, // 0x0400 (1024)
0xE9E2, 0xE1A1, 0xD980, 0xE1A0, 0xD161, 0x80C0, 0xAA06, 0xFF9D, 0xFFFF, 0xFFFF, 0xF73C, 0xBCF3, 0x8ACA, 0x69C5, 0x69A4, 0x7A68, // 0x0410 (1040)
0xA44F, 0xEF5D, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, // 0x0420 (1056)
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, // 0x0430 (1072)
0xFED9, 0xD40E, 0xCAE8, 0xD224, 0xD9E2, 0xD9A1, 0xD960, 0xD940, 0xD940, 0xE140, 0xE180, 0xE180, 0xE181, 0xE980, 0xE980, 0xE9A0, // 0x0440 (1088)
0xE9A1, 0xE9C2, 0xE9E2, 0xF264, 0xEAC6, 0xF2C6, 0xF307, 0xF38A, 0xEB08, 0xD2C7, 0xCAE8, 0xC287, 0x99C4, 0x9183, 0x9182, 0x6901, // 0x0450 (1104)
0x6101, 0x68E1, 0x6102, 0x60E1, 0x7122, 0x8142, 0x8942, 0x9142, 0x9942, 0xB982, 0xB9A2, 0xA962, 0xD1A1, 0xE9C1, 0xE1A2, 0xD9A1, // 0x0460 (1120)
0xE1A1, 0xD162, 0xD182, 0xD182, 0xB982, 0x8100, 0xBB29, 0xFFFF, 0xFFDE, 0xAC70, 0x5944, 0x4080, 0x68C1, 0x8901, 0x9941, 0x9920, // 0x0470 (1136)
0x98E0, 0x8A27, 0xDEDB, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, // 0x0480 (1152)
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xE6DA, // 0x0490 (1168)
0xB182, 0xC900, 0xD981, 0xE180, 0xE181, 0xE981, 0xE9A1, 0xE1C1, 0xE1C1, 0xE9C1, 0xE9C1, 0xE9E2, 0xEA64, 0xF2C7, 0xF2C6, 0xFAE7, // 0x04A0 (1184)
0xFB69, 0xF3AB, 0xE2E8, 0xD308, 0xD2C8, 0xBA45, 0x99A4, 0x8983, 0x9142, 0x7102, 0x58E1, 0x68E1, 0x68E2, 0x48E2, 0x60E1, 0x8942, // 0x04B0 (1200)
0x8162, 0x8962, 0xA162, 0xB182, 0xB982, 0xC9C2, 0xD1C2, 0xD9A1, 0xC9C2, 0xB181, 0xC981, 0xE1C1, 0xD9A0, 0xD9A1, 0xD1A1, 0xD1A1, // 0x04C0 (1216)
0xD1A1, 0xC981, 0xC981, 0xB181, 0x9121, 0x91A5, 0xFF9E, 0xEEDB, 0x7227, 0x4840, 0x8901, 0xC182, 0xD9C2, 0xD1C2, 0xE9A1, 0xE981, // 0x04D0 (1232)
0xE181, 0xC0E0, 0xA267, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, // 0x04E0 (1248)
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xD38C, // 0x04F0 (1264)
0x98E0, 0xE1C1, 0xE1A1, 0xE9C1, 0xF1C1, 0xE9E2, 0xEA02, 0xE9C1, 0xE9A1, 0xF1E2, 0xF3AA, 0xEBAA, 0xF34A, 0xEB4A, 0xCAC7, 0xCA44, // 0x0500 (1280)
0xB1C4, 0xA183, 0x8121, 0x70E1, 0xB121, 0x70E1, 0x7902, 0x70E2, 0x6902, 0x6901, 0x7922, 0x7901, 0x9AC9, 0xA4F2, 0x49C6, 0x99C3, // 0x0510 (1296)
0xD1A2, 0xD1A2, 0xD9C2, 0xD9C2, 0xD9C1, 0xD9A2, 0xD9C2, 0xE1A1, 0xC9A1, 0xA981, 0xB981, 0xD1A1, 0xE1C1, 0xE9C2, 0xE9C1, 0xE1A2, // 0x0520 (1312)
0xE9A1, 0xE9A1, 0xD182, 0xA141, 0x6102, 0xD617, 0xE6DA, 0x8184, 0x80C0, 0xC982, 0xD982, 0xD9A1, 0xD160, 0xE181, 0xD9C2, 0xA286, // 0x0530 (1328)
0xA225, 0x89C4, 0x6922, 0xA4B1, 0xF79E, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, // 0x0540 (1344)
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xF7FF, 0xDBED, // 0x0550 (1360)
0xB920, 0xE9E1, 0xE9C1, 0xE9C1, 0xE9A1, 0xEAC7, 0xEBAA, 0xE9C1, 0xE9E2, 0xE9E2, 0xEA03, 0xE9C2, 0xE1A0, 0xD981, 0x88E1, 0x8922, // 0x0560 (1376)
0x6902, 0x7102, 0x7122, 0x7122, 0x8902, 0x58C1, 0x48E1, 0x58E1, 0x58A1, 0x48A1, 0x8122, 0x9900, 0xB44E, 0xE6FA, 0x52CB, 0x48E1, // 0x0570 (1392)
0xD9A2, 0xD9A1, 0xE1C2, 0xD9A2, 0xD9A1, 0xD9C2, 0xD1C3, 0xD1E3, 0xB981, 0xB981, 0x7122, 0x7142, 0x7941, 0x9941, 0xB961, 0xB981, // 0x0580 (1408)
0xB982, 0xA142, 0x6921, 0x40E2, 0x6142, 0xBBAD, 0x81E5, 0xB100, 0xE1A2, 0xD9A1, 0xD981, 0xC182, 0xBAA8, 0xA941, 0x59E5, 0x52AA, // 0x0590 (1424)
0x52AA, 0x4248, 0x52EB, 0x41E7, 0x5269, 0xAD33, 0xF79D, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, // 0x05A0 (1440)
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFDF, 0xC36B, // 0x05B0 (1456)
0xB120, 0xE1C1, 0xE1C1, 0xD9A1, 0xE9C1, 0xF1C1, 0xE9C2, 0xD9C1, 0xC1A2, 0xC9A2, 0xD182, 0xD1A1, 0xD9A1, 0xC9A2, 0x8922, 0x7102, // 0x05C0 (1472)
0x58E1, 0x50C1, 0x48C2, 0x3082, 0x2061, 0x1861, 0x2041, 0xA9A4, 0xE284, 0xB962, 0x8921, 0xA921, 0x9BAC, 0xF75C, 0x52CB, 0x60E1, // 0x05D0 (1488)
0xEA22, 0xCA24, 0xC9E3, 0xD203, 0xCA03, 0xC9C3, 0xC1E2, 0xC9E2, 0xC182, 0xB961, 0x38E2, 0x5902, 0x6102, 0x40E2, 0x7102, 0x7143, // 0x05E0 (1504)
0x38C2, 0x40A1, 0x6922, 0x8122, 0xC181, 0x88C0, 0xC141, 0xD9A1, 0xD181, 0xE181, 0xE981, 0xA143, 0x6B2C, 0x6289, 0x4A89, 0x5269, // 0x05F0 (1520)
0x5248, 0x5289, 0x5269, 0x3185, 0x3185, 0x4227, 0x41E7, 0xAD55, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, // 0x0600 (1536)
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFDF, 0x9A88, // 0x0610 (1552)
0x90E0, 0xC981, 0xC182, 0xC182, 0xC182, 0xD245, 0xD265, 0xC182, 0xB161, 0xA962, 0xA982, 0xB162, 0xC982, 0x8921, 0x2861, 0x2061, // 0x0620 (1568)
0x1861, 0x1881, 0x1061, 0x3061, 0x6102, 0x48A1, 0x3860, 0x6102, 0x8984, 0x5922, 0x7122, 0xE9A1, 0xB1C3, 0x7B8D, 0x3985, 0x40E2, // 0x0630 (1584)
0x91A3, 0xD203, 0xD1C2, 0xD9C2, 0xD9A2, 0xE1A1, 0xE9C1, 0x9141, 0x9141, 0xD182, 0x40C2, 0x38A2, 0x5902, 0x7923, 0x6921, 0xA942, // 0x0640 (1600)
0xA1C3, 0xA309, 0x9182, 0xD1A1, 0xA942, 0xB982, 0xE9A1, 0xD9A1, 0xCA03, 0x71C5, 0x91C4, 0x832A, 0x4A89, 0x5269, 0x5268, 0x5269, // 0x0650 (1616)
0x5249, 0x4208, 0x5269, 0x3165, 0x20E4, 0x4207, 0x2103, 0x2924, 0xB595, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, // 0x0660 (1632)
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xAB4B, // 0x0670 (1648)
0x8102, 0x5902, 0x40A1, 0x48C1, 0x48A1, 0x5903, 0x5103, 0x50A1, 0xA962, 0xC1A2, 0xC9A2, 0xC9A2, 0xE1C2, 0x9941, 0x1841, 0x3881, // 0x0680 (1664)
0x7122, 0x9122, 0x8942, 0x8941, 0xB9C3, 0xDCF2, 0x9BAD, 0x48E2, 0xA143, 0x6122, 0xA962, 0xE1C2, 0xC9A2, 0x48C1, 0x38C3, 0x30C2, // 0x0690 (1680)
0x9162, 0xE1C1, 0xE1A1, 0xE1C1, 0xE1A1, 0xE9C1, 0xC9A2, 0x40C2, 0x8141, 0xD9C2, 0x9162, 0x38E2, 0x6102, 0x7922, 0x6902, 0x7902, // 0x06A0 (1696)
0xE182, 0x9AC8, 0xA9A4, 0xC181, 0x8942, 0xC962, 0xD981, 0xE160, 0xD2A7, 0x7BCF, 0x2986, 0x4A48, 0x5228, 0x734C, 0x8C0F, 0x5248, // 0x06B0 (1712)
0x20E3, 0x2924, 0x2924, 0x2924, 0x2103, 0x2124, 0x2104, 0x2904, 0x39A6, 0xEF5D, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, // 0x06C0 (1728)
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xB3EE, // 0x06D0 (1744)
0x8122, 0x5903, 0x2840, 0x3881, 0x4081, 0x40E2, 0x38C2, 0x4081, 0xB162, 0xC982, 0xC9A2, 0xD1A2, 0xE1C1, 0x9941, 0x2060, 0xA9A2, // 0x06E0 (1760)
0xD204, 0xB162, 0xB182, 0xA142, 0xA941, 0xCC90, 0xDE9A, 0x7207, 0xB1A2, 0xA142, 0xD1A2, 0xD1A2, 0xE9C2, 0xA962, 0x3902, 0x7142, // 0x06F0 (1776)
0xD981, 0xE1C2, 0xD9E2, 0xDA43, 0xD204, 0xD9A1, 0x9962, 0x38E2, 0x7122, 0xC9A1, 0xC161, 0x8142, 0x9982, 0xC161, 0x6122, 0x38E2, // 0x0700 (1792)
0xA141, 0xB982, 0x8142, 0xA941, 0x6122, 0xA161, 0xF1A1, 0xF181, 0xA1C4, 0x83EE, 0x39A6, 0x5AA9, 0x8C0F, 0xAD13, 0x9C91, 0x5AA9, // 0x0710 (1808)
0x3185, 0x20E3, 0x2104, 0x2104, 0x18E3, 0x18E3, 0x18C3, 0x2924, 0x18A2, 0x9491, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, // 0x0720 (1824)
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xB470, // 0x0730 (1840)
0x7902, 0x6923, 0x3881, 0x4881, 0x48A0, 0x50E2, 0x48C2, 0x60C1, 0xC982, 0xC9A2, 0xD1A2, 0xD1A2, 0xE1C1, 0xA161, 0x30A1, 0xB983, // 0x0740 (1856)
0x9942, 0x8942, 0x8121, 0xB182, 0xC981, 0xA962, 0xCD34, 0x9C70, 0xBA04, 0xA121, 0xD1A2, 0xD1C2, 0xE1C2, 0xE1C2, 0xC9A3, 0xCA04, // 0x0750 (1872)
0xD203, 0xD244, 0xD204, 0xD204, 0xE1E2, 0xA142, 0x4102, 0x40E3, 0x5922, 0xB9C2, 0xB9A2, 0xA162, 0x9162, 0xB162, 0x5922, 0x38C2, // 0x0760 (1888)
0x5901, 0xC9A2, 0xA962, 0x8941, 0x38E3, 0x7102, 0x9942, 0x8162, 0x4164, 0x62EB, 0x736C, 0x6B2C, 0x7BAD, 0x5A69, 0x39A6, 0x2944, // 0x0770 (1904)
0x2104, 0x20E3, 0x20C3, 0x20C3, 0x18E3, 0x18C3, 0x18A2, 0x20E3, 0x18A2, 0x2945, 0xD6BA, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, // 0x0780 (1920)
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xC4F3, // 0x0790 (1936)
0x70E1, 0x6123, 0x4061, 0x48A1, 0x48A1, 0x48E2, 0x48C2, 0x68C1, 0xC9C1, 0xD1C2, 0xD1C1, 0xD9C2, 0xE1C1, 0xA922, 0x48E2, 0x4144, // 0x07A0 (1952)
0x28C2, 0x8942, 0xA182, 0x8121, 0x8963, 0x7901, 0x6A07, 0xC618, 0xA2C9, 0xB961, 0xC9C2, 0xD9E2, 0xDA85, 0xC9C3, 0xD9E2, 0xD9E2, // 0x07B0 (1968)
0xD9C2, 0xD9A1, 0xE1C2, 0xE9A1, 0xD182, 0x4902, 0x38E3, 0x38E3, 0x6123, 0xB9C3, 0xB9A2, 0x9942, 0x6143, 0x5122, 0x8922, 0x5902, // 0x07C0 (1984)
0x5902, 0x9983, 0x8942, 0x6921, 0x40C2, 0x5164, 0x4A68, 0x4248, 0x83AF, 0x5A69, 0x62EA, 0x6B0B, 0x5269, 0x3165, 0x2924, 0x20E3, // 0x07D0 (2000)
0x18C3, 0x18C2, 0x31A5, 0x4A28, 0x41E7, 0x20E3, 0x18A2, 0x20C3, 0x20C3, 0x18C2, 0x736D, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, // 0x07E0 (2016)
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xD595, // 0x07F0 (2032)
0x8101, 0x7164, 0x4881, 0x50A1, 0x4080, 0x40C2, 0x40A2, 0x70E2, 0xD1A2, 0xD9C2, 0xD9C2, 0xE1C2, 0xE9E2, 0xB161, 0x3922, 0x2965, // 0x0800 (2048)
0x2104, 0x2103, 0x30A2, 0x3081, 0xBA05, 0x68C1, 0x80E0, 0xDD53, 0xA4D2, 0xA1A2, 0x9942, 0xE1C2, 0xE1E2, 0xE9A1, 0xE9C1, 0xE9C1, // 0x0810 (2064)
0xE9C1, 0xE9E1, 0xE9C2, 0xE1C2, 0x7142, 0x30E3, 0x6143, 0x5922, 0x9962, 0xD9C3, 0xC9A2, 0xA182, 0x9162, 0x8122, 0x9142, 0x9162, // 0x0820 (2080)
0x9143, 0x4902, 0x6122, 0x7922, 0x48E2, 0x5185, 0x734C, 0x3986, 0x41E7, 0x6B0C, 0xBDB5, 0xD678, 0x8C30, 0x39A6, 0x2924, 0x18C3, // 0x0830 (2096)
0x2924, 0x632C, 0x736D, 0x7BAD, 0x83CF, 0x7B8E, 0x39A6, 0x1082, 0x18C3, 0x18A2, 0x9492, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, // 0x0840 (2112)
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xDE37, // 0x0850 (2128)
0x98E1, 0x6122, 0x4081, 0x4861, 0x3860, 0x38C2, 0x30A1, 0x8101, 0xD9A1, 0xD9C2, 0xD9C2, 0xE1C2, 0xF1E1, 0xA982, 0x2165, 0x5248, // 0x0860 (2144)
0x4A48, 0x4208, 0x5185, 0xA142, 0xCA44, 0x8102, 0xD960, 0xD265, 0xC5F8, 0x830B, 0x78E1, 0xE1A1, 0xF1C1, 0xE9C1, 0xE1C2, 0xD1A2, // 0x0870 (2160)
0xC162, 0x9943, 0x8142, 0x6122, 0x30E3, 0x5903, 0xB1A3, 0xB182, 0xB9A2, 0xB1A3, 0xA182, 0x9963, 0x9183, 0xB9A3, 0xA982, 0x9942, // 0x0880 (2176)
0x8942, 0x9962, 0xA982, 0xC1C3, 0x6902, 0x38C2, 0x838D, 0x4A48, 0x5AAA, 0x9C90, 0xBD94, 0x9470, 0x4A08, 0x20E3, 0x18A2, 0x2904, // 0x0890 (2192)
0xB5F7, 0xB470, 0x80C0, 0x7207, 0x630B, 0x7B8D, 0x83CE, 0x2924, 0x18C3, 0x1081, 0x630B, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, // 0x08A0 (2208)
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xEEFB, // 0x08B0 (2224)
0xA163, 0x6922, 0x40A1, 0x3881, 0x3060, 0x30A1, 0x3082, 0x9121, 0xE1C2, 0xE1C1, 0xE1C2, 0xE9E1, 0xF9E2, 0xB182, 0x18C3, 0x18E3, // 0x08C0 (2240)
0x18E3, 0x18E3, 0x18C2, 0x6101, 0xD203, 0x9122, 0xD181, 0xD940, 0xCC2D, 0x8C51, 0x5923, 0x9121, 0x8962, 0x7122, 0x50E2, 0x6164, // 0x08D0 (2256)
0x7964, 0x40E2, 0x6923, 0x7122, 0x7142, 0x8183, 0xA162, 0xB163, 0x9962, 0xA1C3, 0xD285, 0xDA44, 0xE265, 0xF223, 0xC9A2, 0xB183, // 0x08E0 (2272)
0xC9A2, 0xD182, 0xA162, 0xB962, 0x7122, 0x3924, 0x5A89, 0x5A89, 0x83AD, 0xAD13, 0x9450, 0x2945, 0x2104, 0x20E3, 0x18A2, 0xAD75, // 0x08F0 (2288)
0xFF5C, 0xD266, 0x8080, 0xC513, 0xB5D7, 0x62EB, 0x9450, 0x6B0B, 0x18A2, 0x18E3, 0x18C3, 0xB5B6, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, // 0x0900 (2304)
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xF77E, // 0x0910 (2320)
0xA1C5, 0x7922, 0x3881, 0x3081, 0x3081, 0x38C2, 0x3082, 0x9921, 0xE1A1, 0xE1C1, 0xE9C1, 0xE9C1, 0xF9E1, 0xB161, 0x18E3, 0x2924, // 0x0920 (2336)
0x2104, 0x2104, 0x28C2, 0x8123, 0xA9E3, 0x8941, 0xB9A2, 0xE9A1, 0xD1A1, 0xC595, 0xA32C, 0x68E0, 0x38E2, 0x58E3, 0x7942, 0x9205, // 0x0930 (2352)
0x6943, 0xD1A2, 0xC9C2, 0xC9A1, 0xC9C2, 0x8983, 0x9962, 0xE9C2, 0xC9A1, 0xC182, 0xE9A2, 0xF1C2, 0xE9A1, 0xE1C1, 0xA963, 0x9182, // 0x0940 (2368)
0xC9C2, 0xC9A2, 0xA962, 0x9182, 0x41C6, 0x3186, 0x41E7, 0x9450, 0x83CD, 0x5AAA, 0x41C6, 0x3986, 0x2924, 0x1061, 0x7BAE, 0xFFFF, // 0x0950 (2384)
0xE3CE, 0xC8C0, 0xA0C0, 0xCCD1, 0xFFFF, 0x8C30, 0x9471, 0x9C71, 0x2945, 0x20E3, 0x0861, 0x8C51, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, // 0x0960 (2400)
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xF79E, // 0x0970 (2416)
0x91C6, 0x8101, 0x40A1, 0x3060, 0x3861, 0x38C2, 0x38A2, 0xA162, 0xE1C1, 0xE9C1, 0xF1C1, 0xF1C1, 0xF9E1, 0xB161, 0x20A2, 0x40E2, // 0x0980 (2432)
0x48E1, 0x48E2, 0x60C1, 0xB1A2, 0xDA03, 0xB1C3, 0xB1C3, 0xC203, 0xF308, 0xC34A, 0xC5B4, 0xB9A3, 0x9100, 0xF1E2, 0xE203, 0x81C5, // 0x0990 (2448)
0x9982, 0xE1E2, 0xC161, 0xC9A2, 0xB1A3, 0x9942, 0xB1A2, 0xF1C2, 0xD1A2, 0x9962, 0xB982, 0xC9C2, 0xE9C2, 0xD982, 0xB181, 0xC1A3, // 0x09A0 (2464)
0xB9C3, 0xC9A3, 0xD182, 0xB204, 0x4A49, 0x5AAA, 0x8C0E, 0x5AA9, 0x736C, 0xC5D5, 0x83EF, 0x3165, 0x20E3, 0x2945, 0xD699, 0xD69A, // 0x09B0 (2480)
0x9183, 0xB1A3, 0xD940, 0xAA47, 0xFFFF, 0xCE38, 0xA4B1, 0xB554, 0x4207, 0x1061, 0x4208, 0xF79D, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, // 0x09C0 (2496)
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFDF, // 0x09D0 (2512)
0x9227, 0x88E1, 0x4081, 0x3861, 0x3881, 0x38E2, 0x38A2, 0xA941, 0xE1C1, 0xE9C1, 0xF1E1, 0xF1C1, 0xF9E1, 0xA161, 0x3081, 0xC9A2, // 0x09E0 (2528)
0xD9C1, 0xE1C2, 0xE1C2, 0xC204, 0xAA05, 0x6142, 0x60E1, 0xB2C8, 0xDC0D, 0x98E0, 0xB4D2, 0xCDB4, 0x9A46, 0xE160, 0xB1E4, 0x7163, // 0x09F0 (2544)
0xD9C3, 0xB1C2, 0xB9C3, 0xB1A3, 0xB9A3, 0xD1E2, 0xD9A2, 0xE9C1, 0xD1A1, 0xA142, 0x5922, 0x9962, 0xF1C1, 0xE9A1, 0xE1A1, 0xEA24, // 0x0A00 (2560)
0xE1E3, 0xC9A2, 0xB982, 0x7963, 0x6AEA, 0x41E8, 0x5248, 0x6B2B, 0xC5B5, 0xCE16, 0x62CB, 0x20C3, 0x10C3, 0x6A48, 0xB266, 0x8142, // 0x0A10 (2576)
0x9921, 0xD9C3, 0xE9A1, 0xA100, 0xD639, 0xF79D, 0xAD13, 0xCDF6, 0x6B0B, 0x0821, 0x5269, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, // 0x0A20 (2592)
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, // 0x0A30 (2608)
0xAAC9, 0x80C1, 0x48A1, 0x2880, 0x3861, 0x40E2, 0x48C2, 0xB961, 0xE9C1, 0xE9C1, 0xF1E1, 0xF1C1, 0xF9E1, 0xB161, 0x7101, 0xE1C2, // 0x0A40 (2624)
0xE9E2, 0xE1C1, 0xE1E2, 0xC1A2, 0x8121, 0xA141, 0x8100, 0xCB6B, 0xEC4E, 0x90E0, 0x8142, 0x8B6D, 0xC5F6, 0xD3ED, 0x7122, 0xB960, // 0x0A50 (2640)
0xF9E2, 0xB9A2, 0xD1C2, 0xCA03, 0xA982, 0xB9A2, 0xA162, 0xA982, 0xA982, 0xA962, 0x9962, 0xC182, 0xF1C1, 0xD9A2, 0xE1A1, 0xE1E3, // 0x0A60 (2656)
0xD1A2, 0xE9A2, 0xA982, 0x38A1, 0x730A, 0x5269, 0x41C7, 0x62CA, 0x83CE, 0x6B0B, 0x3165, 0x20C4, 0x2966, 0xAA46, 0xF140, 0xE160, // 0x0A70 (2672)
0xF1A1, 0xC182, 0xC1A2, 0xD0E0, 0xB3EE, 0xF7FF, 0xB574, 0xD678, 0x83CE, 0x1082, 0x18C3, 0xBDF7, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, // 0x0A80 (2688)
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, // 0x0A90 (2704)
0xBBAD, 0x88C1, 0x48C2, 0x2861, 0x3840, 0x40C2, 0x48E2, 0xC182, 0xE1E2, 0xE9C1, 0xF1C1, 0xF1C1, 0xF9C1, 0xC1C3, 0xAA66, 0xA942, // 0x0AA0 (2720)
0xF1C1, 0xC1C3, 0xA162, 0xF1C2, 0xF1C2, 0xF9E1, 0xC141, 0xB2A7, 0xAB4A, 0x78E1, 0xA961, 0x9900, 0x7A06, 0xAD74, 0xBCB1, 0xE224, // 0x0AB0 (2736)
0xC961, 0x9101, 0xB962, 0xC9E2, 0x8121, 0x50A2, 0x7142, 0x8142, 0xA982, 0xA183, 0xC982, 0x8941, 0xB162, 0xD9E2, 0xC981, 0xC182, // 0x0AC0 (2752)
0xA962, 0xE1C1, 0x9162, 0x4123, 0x5228, 0x732C, 0x3985, 0x5269, 0x734C, 0x39A6, 0x2924, 0x20C4, 0x31A6, 0x9983, 0xE9A1, 0xE9A1, // 0x0AD0 (2768)
0xE9A1, 0xD161, 0xC182, 0xB921, 0x9205, 0xD638, 0xCDF7, 0xE6D9, 0x8C2F, 0x18C3, 0x1061, 0x840F, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, // 0x0AE0 (2784)
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, // 0x0AF0 (2800)
0xBC51, 0x90C0, 0x50C1, 0x2881, 0x2840, 0x30E2, 0x40E2, 0xC982, 0xD9E2, 0xE9E1, 0xF1C1, 0xF1C1, 0xF1E1, 0xBA24, 0x89E5, 0xA163, // 0x0B00 (2816)
0xF9E2, 0xC1E3, 0xC1A2, 0xE9C1, 0xE9C1, 0xE9C1, 0xF1E1, 0xE181, 0xA100, 0xA162, 0xC182, 0xC182, 0xB141, 0x7903, 0x93CE, 0xC574, // 0x0B10 (2832)
0x9B0B, 0x92EA, 0xB205, 0xB920, 0x8247, 0x8AEA, 0x90E0, 0x9921, 0xB182, 0xB982, 0xB9A2, 0x7122, 0xA162, 0xC9A1, 0xC181, 0xC9A2, // 0x0B20 (2848)
0xB181, 0xC9A2, 0x8962, 0x31C6, 0x31A6, 0x3165, 0x5AAA, 0x6B0B, 0x62CA, 0x4A28, 0x3165, 0x18C3, 0x62A9, 0x6963, 0xB961, 0xE9A1, // 0x0B30 (2864)
0xE9A1, 0xE9E3, 0xA162, 0x8122, 0x9101, 0x8121, 0xCD74, 0xF75B, 0x8C0F, 0x18A3, 0x10A2, 0xBDF7, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, // 0x0B40 (2880)
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, // 0x0B50 (2896)
0xBCD2, 0x98A0, 0xB981, 0xA161, 0xA142, 0x99C4, 0xA1A3, 0xD9A2, 0xD9A2, 0xE9C1, 0xF1C1, 0xF1C1, 0xF9E1, 0xA9E3, 0x71C5, 0xA1A2, // 0x0B60 (2912)
0xE9C2, 0xE1A1, 0xE9C1, 0xF1E1, 0xF1E1, 0xF1C1, 0xF1C1, 0xD9A1, 0xD1A2, 0xB182, 0xB9A1, 0xA983, 0x9941, 0x6080, 0x938E, 0xBD54, // 0x0B70 (2928)
0xB513, 0xE6DB, 0xE658, 0xCC50, 0xF75D, 0xF71B, 0xC533, 0xAC70, 0xB1E4, 0x9920, 0xA183, 0xD1C2, 0xE1A1, 0xE1C1, 0xE1C1, 0xE181, // 0x0B80 (2944)
0xD1A2, 0xB142, 0x6963, 0x4207, 0x4A28, 0x5269, 0x5249, 0x5A89, 0xA4D2, 0x5269, 0x2103, 0x18C2, 0xB554, 0x8A48, 0x88E1, 0xE9A1, // 0x0B90 (2960)
0xE9A1, 0xDA24, 0xA941, 0xB961, 0xB942, 0x932B, 0xEED9, 0xEF3B, 0x734C, 0x0841, 0x8C51, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, // 0x0BA0 (2976)
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, // 0x0BB0 (2992)
0xDD74, 0xA0E0, 0xD1A2, 0xF1C1, 0xF9C1, 0xF9E2, 0xF1E2, 0xD9A1, 0xD9A2, 0xE9C1, 0xF1E2, 0xF1E2, 0xF9E1, 0xA962, 0x8944, 0xA182, // 0x0BC0 (3008)
0xD9C2, 0xD9C1, 0xC9A1, 0xD1A2, 0xD9C2, 0xB9A2, 0x9942, 0x7102, 0x5101, 0x5901, 0xA163, 0x58C1, 0x38E3, 0x5164, 0xE6B9, 0xFFFF, // 0x0BD0 (3024)
0xCDD7, 0xA491, 0xCDB6, 0xF7BE, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xD40E, 0x90C0, 0x9142, 0x9101, 0x9962, 0xB162, 0x8942, 0x7A26, // 0x0BE0 (3040)
0x89C4, 0x7268, 0x49C7, 0x5A48, 0x4A29, 0x5269, 0x39A6, 0x62CB, 0x6B2C, 0x39A6, 0x2924, 0x20E3, 0xBDB6, 0xAA46, 0x9901, 0xD9A1, // 0x0BF0 (3056)
0xD181, 0xA920, 0xB141, 0xA982, 0xA122, 0xD4B0, 0xF79C, 0xE6FA, 0x5269, 0x0820, 0x9CB2, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, // 0x0C00 (3072)
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, // 0x0C10 (3088)
0xEE37, 0xB941, 0xC982, 0xE1C1, 0xE9C1, 0xE9C1, 0xE9C1, 0xD9A1, 0xD1A1, 0xE9C1, 0xF1C1, 0xF1E1, 0xD9A2, 0xB961, 0xB1A2, 0xA9A3, // 0x0C20 (3104)
0xB182, 0xD9E3, 0xB982, 0x7942, 0x5122, 0x4103, 0x40A1, 0x38A1, 0x50C1, 0x7942, 0x6123, 0x4902, 0xD679, 0xF79D, 0xFFFF, 0xFFFF, // 0x0C30 (3120)
0xFFFF, 0xEF1C, 0xB513, 0xB533, 0xDE78, 0xFFDF, 0xFFFF, 0xFFFF, 0xF7BF, 0xCE17, 0xBC2F, 0xC42F, 0xA450, 0x8A47, 0xB575, 0xD6FB, // 0x0C40 (3136)
0xBAE9, 0xB3CD, 0xD679, 0x9CD3, 0x2924, 0x3165, 0x3986, 0x41C7, 0x41C7, 0x41E7, 0x2924, 0x2145, 0xB34B, 0xE181, 0xC961, 0xB962, // 0x0C50 (3152)
0xB181, 0x8901, 0x78E2, 0x78C0, 0x8247, 0xE657, 0xF77C, 0xD678, 0x3986, 0x1061, 0x4A28, 0xFFDE, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, // 0x0C60 (3168)
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xE73C, 0xA4D3, // 0x0C70 (3184)
0x7ACA, 0xC9A2, 0xC981, 0xE1C2, 0xE9E1, 0xE9C1, 0xE9C1, 0xD1A1, 0xD1C1, 0xE9C1, 0xF1C1, 0xF1C1, 0xB982, 0xCA03, 0xC1E2, 0x8961, // 0x0C80 (3200)
0x6903, 0x8142, 0x7121, 0x48C2, 0x60A1, 0xA100, 0xCB4A, 0xD5D5, 0xA1A3, 0x8921, 0x6060, 0x8B6D, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFDF, // 0x0C90 (3216)
0xFFFF, 0xFFFF, 0xFFFF, 0xD659, 0xB4F3, 0xCD96, 0xEEFB, 0xEF3C, 0xDE79, 0xC595, 0xACD2, 0xB5B6, 0xD554, 0xC32A, 0xC5F7, 0xA4D1, // 0x0CA0 (3232)
0x91A3, 0xA309, 0xCE18, 0x5AEB, 0x39A6, 0x2924, 0x3144, 0x41E7, 0x41E7, 0x2104, 0x20E3, 0x2186, 0xA9A3, 0xC9A2, 0xE1A2, 0xD961, // 0x0CB0 (3248)
0xD181, 0xB161, 0x70A0, 0x81C6, 0xEF5C, 0xF75C, 0xF77B, 0xB553, 0x2924, 0x1082, 0x630C, 0xFFDF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, // 0x0CC0 (3264)
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xBDD6, 0x6B4C, 0x71E6, // 0x0CD0 (3280)
0x7183, 0xB9C2, 0xD1C2, 0xE9E1, 0xF1C1, 0xF223, 0xEA03, 0xD9C1, 0xD9C1, 0xF1C1, 0xE9E2, 0xC9A2, 0xD1A1, 0xDA03, 0xB1A2, 0x8123, // 0x0CE0 (3296)
0x8963, 0xB1E3, 0x7983, 0x79E4, 0xC287, 0xB2C8, 0xC533, 0xDD54, 0xA962, 0xA100, 0xA205, 0xE69A, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, // 0x0CF0 (3312)
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xEF3C, 0xB554, 0x9C71, 0xACF3, 0xC596, 0xCDF7, 0xAC91, 0xB4D2, 0x8AA9, 0x9A26, 0xB40F, 0xC450, // 0x0D00 (3328)
0xD574, 0xFF1C, 0xB535, 0x18C3, 0x3165, 0x2924, 0x3986, 0x4A08, 0x3986, 0x2945, 0x2924, 0x2966, 0x89C4, 0xD980, 0xE140, 0xD181, // 0x0D10 (3344)
0xB161, 0xB161, 0xA121, 0xDE17, 0xF7BD, 0xEF1A, 0xEF5A, 0x738C, 0x1081, 0x8410, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, // 0x0D20 (3360)
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xAD34, 0x5A89, 0x41E7, 0x69E6, // 0x0D30 (3376)
0x9162, 0x8942, 0x9962, 0xC1A2, 0xB961, 0xC285, 0xC224, 0xB961, 0xB982, 0xB182, 0x8142, 0x9962, 0xD9C2, 0x8942, 0x3060, 0x78C1, // 0x0D40 (3392)
0x79E4, 0x930A, 0x8A68, 0x8ACA, 0x93CD, 0x93CF, 0xABEE, 0xD4B0, 0xCD74, 0x91E5, 0xBC2F, 0xFFFF, 0xFFDF, 0xFFFF, 0xFFFF, 0xFFFF, // 0x0D50 (3408)
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xE73C, 0xEF5C, 0xFFDF, 0xFFFF, 0xFF9D, 0xDDD6, 0xDDB6, 0xF6FA, 0xFFBE, 0xFFFF, // 0x0D60 (3424)
0xFFFF, 0xFFFF, 0xD6DB, 0x39C7, 0x2924, 0x3165, 0x39A6, 0x2945, 0x41C7, 0x3165, 0x2945, 0x2165, 0x71A4, 0xB901, 0xBA87, 0x91A4, // 0x0D70 (3440)
0x9141, 0xC900, 0xC3AC, 0xF7DF, 0xE6D9, 0xEF3B, 0xCE17, 0x39A6, 0x18C2, 0xD69A, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, // 0x0D80 (3456)
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xAD54, 0x4A48, 0x4A07, 0x5269, 0x2965, // 0x0D90 (3472)
0x3904, 0x7A06, 0x7983, 0xA162, 0x9942, 0x91C4, 0x9183, 0x9142, 0x8141, 0x8142, 0x8162, 0xA9A2, 0x8942, 0x6184, 0x9BAE, 0x92C8, // 0x0DA0 (3488)
0x99C4, 0xC4F2, 0xE6FA, 0xFFBE, 0xFFDF, 0xFFFF, 0xFFFF, 0xFFFF, 0xDD75, 0xC3CC, 0xF6FC, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, // 0x0DB0 (3504)
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, // 0x0DC0 (3520)
0xFFFF, 0xFFFF, 0xFFFF, 0x7BAE, 0x3165, 0x2945, 0x2104, 0x3165, 0x39A6, 0x4208, 0x3986, 0x20E4, 0x6ACA, 0xE6BA, 0xF7FF, 0xB4D2, // 0x0DD0 (3536)
0x98E0, 0xA182, 0xD638, 0xEF3B, 0xE6D9, 0xEF1A, 0x83CF, 0x2904, 0x0840, 0xAD55, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, // 0x0DE0 (3552)
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xDEDA, 0x5248, 0x3986, 0x5289, 0x39A6, 0x3A08, // 0x0DF0 (3568)
0x934C, 0x9B4B, 0x9A47, 0x8921, 0xA961, 0x9962, 0xB181, 0xD9C2, 0xB981, 0xA162, 0xB181, 0xC182, 0x99C3, 0xE6BA, 0xFFFF, 0xFFFF, // 0x0E00 (3584)
0xE5F6, 0xC3ED, 0xCC0E, 0xE658, 0xFFFF, 0xFFFF, 0xEF5C, 0xB3CD, 0xB36B, 0xF77D, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, // 0x0E10 (3600)
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, // 0x0E20 (3616)
0xFFFF, 0xFFFF, 0xFFFF, 0xA514, 0x2124, 0x2103, 0x2924, 0x2924, 0x39A6, 0x41C7, 0x2924, 0x2924, 0x5ACA, 0xFFDF, 0xFFFF, 0xF7BE, // 0x0E30 (3632)
0xB1E5, 0x8901, 0xC554, 0xE6FA, 0xE6FA, 0xB574, 0x41E7, 0x20C3, 0x18C2, 0xAD55, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, // 0x0E40 (3648)
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0x8C30, 0x3985, 0x41E7, 0x41E7, 0x39E8, 0xAC2F, // 0x0E50 (3664)
0xDA03, 0xB141, 0xA961, 0xAA46, 0xB3AD, 0xC981, 0x9121, 0x8121, 0x7142, 0x60C0, 0xA100, 0xD9A1, 0xD1E1, 0xEB69, 0xEDD5, 0xFFFF, // 0x0E60 (3680)
0xFFFF, 0xFFFF, 0xDE58, 0x9A27, 0xA30A, 0xCCF2, 0xA246, 0x99C4, 0xF7BE, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, // 0x0E70 (3696)
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, // 0x0E80 (3712)
0xFFFF, 0xFFFF, 0xFFFF, 0x9CB2, 0x18C3, 0x3186, 0x2924, 0x2924, 0x3186, 0x2104, 0x2904, 0x3165, 0x39C6, 0x9CB2, 0xE71C, 0xDEFB, // 0x0E90 (3728)
0xBD13, 0xA36B, 0xD616, 0xE6FA, 0xC5D6, 0x5ACA, 0x20E3, 0x5269, 0xDEDA, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, // 0x0EA0 (3744)
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xE73C, 0x4A49, 0x3165, 0x39A6, 0x2924, 0x8C0F, 0xE265, // 0x0EB0 (3760)
0xE1A1, 0x9162, 0xC181, 0x9942, 0x8C30, 0xC1E3, 0x81A4, 0x4944, 0x50C1, 0xA3AC, 0xCBED, 0xB161, 0xD140, 0xE980, 0xEA65, 0xE349, // 0x0EC0 (3776)
0xD46F, 0xF79C, 0xEF7C, 0xC267, 0x7880, 0x8983, 0x81A3, 0x8944, 0xEF3C, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, // 0x0ED0 (3792)
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, // 0x0EE0 (3808)
0xFFFF, 0xFFFF, 0xFFFF, 0xE73C, 0x3186, 0x2103, 0x3145, 0x3165, 0x2945, 0x2904, 0x2904, 0x3145, 0x39C6, 0x5A8A, 0xB554, 0xCE17, // 0x0EF0 (3824)
0xCE57, 0xD658, 0xDE79, 0xBD75, 0x734C, 0x3986, 0x20C3, 0xD699, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, // 0x0F00 (3840)
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xAD75, 0x2904, 0x2944, 0x20E3, 0x4A28, 0xB40F, 0xB941, // 0x0F10 (3856)
0xB981, 0xA9C3, 0xB1A2, 0x80E1, 0x6269, 0xBCF2, 0xC553, 0x4207, 0x0841, 0xB5B6, 0xFFFF, 0xE679, 0xAB4B, 0xA942, 0xD1C3, 0xEB07, // 0x0F20 (3872)
0xCA04, 0xBA67, 0xA1C4, 0xB961, 0x9206, 0xDEBA, 0xEF3B, 0xDDB5, 0xF7BE, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, // 0x0F30 (3888)
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, // 0x0F40 (3904)
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xA514, 0x1882, 0x3165, 0x2924, 0x20E3, 0x2924, 0x3186, 0x2924, 0x3165, 0x4A28, 0x6B2B, 0xA4F2, // 0x0F50 (3920)
0xBDB5, 0xB553, 0x9471, 0x732C, 0x41C7, 0x18A2, 0x1082, 0xD69A, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, // 0x0F60 (3936)
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0x7BCE, 0x1062, 0x20C3, 0x1081, 0x738E, 0xD329, 0xB940, // 0x0F70 (3952)
0xA982, 0xB9C2, 0xB9A3, 0x70E1, 0x6227, 0xE6FA, 0xE6F9, 0x41A6, 0x1061, 0xB5B6, 0xFFFF, 0xFFFF, 0xFFFF, 0xDE78, 0xAB6A, 0xB141, // 0x0F80 (3968)
0x9982, 0xA9E4, 0xB224, 0xC9A1, 0xB30A, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, // 0x0F90 (3984)
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, // 0x0FA0 (4000)
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0x62EB, 0x18A2, 0x20E3, 0x20E3, 0x3165, 0x3186, 0x20E3, 0x2924, 0x39A6, 0x5269, 0x6B2B, // 0x0FB0 (4016)
0x7BAD, 0x736C, 0x62CA, 0x39A6, 0x1882, 0x5269, 0x8430, 0xDEFB, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, // 0x0FC0 (4032)
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0x738E, 0x0821, 0x18A2, 0x1082, 0x8430, 0xDB49, 0xD960, // 0x0FD0 (4048)
0x9962, 0x8142, 0xC182, 0x68E1, 0x7902, 0xEDF5, 0xD678, 0x3144, 0x20E3, 0xD699, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xE679, // 0x0FE0 (4064)
0xA288, 0x8901, 0xBA04, 0xCAA6, 0x8AA8, 0xA4B1, 0x8C10, 0x9451, 0xAD34, 0xEF3C, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, // 0x0FF0 (4080)
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, // 0x1000 (4096)
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xD69A, 0x20C3, 0x20C3, 0x2904, 0x2924, 0x20E3, 0x20E3, 0x2945, 0x2924, 0x3145, 0x41E7, // 0x1010 (4112)
0x4A28, 0x41A6, 0x2924, 0x18A2, 0x41C7, 0xEF7D, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, // 0x1020 (4128)
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0x83EF, 0x0820, 0x18C3, 0x1082, 0x7C0F, 0xDB8B, 0xB100, // 0x1030 (4144)
0x9983, 0x8942, 0x80A0, 0x71C5, 0xC574, 0xF73A, 0xACF2, 0x18A2, 0x41C7, 0xFFDF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, // 0x1040 (4160)
0xED94, 0x9942, 0x8AC9, 0x9C2F, 0x8BEF, 0x62A9, 0x41C6, 0x41C6, 0x3145, 0x4A07, 0xA4F3, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, // 0x1050 (4176)
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, // 0x1060 (4192)
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0x9CB3, 0x1882, 0x20E3, 0x28E3, 0x20C3, 0x2924, 0x3165, 0x20E3, 0x2924, 0x2944, // 0x1070 (4208)
0x2904, 0x20E3, 0x1882, 0x18A2, 0x5249, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, // 0x1080 (4224)
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xB575, 0x1021, 0x18C3, 0x1081, 0x4A28, 0x9A88, 0x8183, // 0x1090 (4240)
0xA941, 0xC1C3, 0xB32A, 0xD5D6, 0xE75B, 0xE6FA, 0x5AAA, 0x0820, 0x8C30, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, // 0x10A0 (4256)
0xC5F7, 0x93CD, 0x9C90, 0x7BAE, 0x39E6, 0x3164, 0x3145, 0x2924, 0x2924, 0x2104, 0x18A2, 0x7BCF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, // 0x10B0 (4272)
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, // 0x10C0 (4288)
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xBDB6, 0x3145, 0x1041, 0x18A2, 0x2924, 0x2104, 0x18C3, 0x3165, 0x18C3, // 0x10D0 (4304)
0x1882, 0x18C2, 0x8C71, 0xCE58, 0xBDB6, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, // 0x10E0 (4320)
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xEF5D, 0x2924, 0x1082, 0x18C3, 0x2904, 0x736D, 0xC5B6, // 0x10F0 (4336)
0xD594, 0xD658, 0xE73C, 0xE73B, 0xEEFA, 0x8C2F, 0x2104, 0x2945, 0xEF5D, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xC5F7, // 0x1100 (4352)
0x7BAD, 0x83CE, 0x630B, 0x3986, 0x2924, 0x2124, 0x18A3, 0x18C2, 0x18A2, 0x18C3, 0x2924, 0x1882, 0xA514, 0xFFFF, 0xFFFF, 0xFFFF, // 0x1110 (4368)
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, // 0x1120 (4384)
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xE73C, 0x7BCF, 0x3165, 0x18A2, 0x20E3, 0x2904, 0x1061, 0x6B2C, // 0x1130 (4400)
0x94B2, 0x39E7, 0xDEFB, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, // 0x1140 (4416)
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0x8C30, 0x0000, 0x18C3, 0x18C3, 0x39C6, 0x9491, // 0x1150 (4432)
0xCE78, 0xD678, 0xD657, 0xCE16, 0x8C0F, 0x39A6, 0x1061, 0xB596, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xD6BA, 0x62CA, // 0x1160 (4448)
0x6B0B, 0x5A89, 0x3185, 0x2944, 0x20E3, 0x39A6, 0x736D, 0x8C2F, 0x83CE, 0x39A7, 0x18C3, 0x20E3, 0x39C7, 0xEF7D, 0xFFFF, 0xFFFF, // 0x1170 (4464)
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, // 0x1180 (4480)
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xE71C, 0xB575, 0xB596, 0xB596, 0x630C, 0xE75D, // 0x1190 (4496)
0xFFFF, 0xEF7D, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, // 0x11A0 (4512)
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xF7BE, 0x5249, 0x0000, 0x20C3, 0x2924, 0x4A08, // 0x11B0 (4528)
0x736D, 0x8BCE, 0x83AE, 0x5AAA, 0x2924, 0x0861, 0x9CD2, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFDF, 0x738E, 0x41E7, // 0x11C0 (4544)
0x4A48, 0x39A6, 0x2945, 0x20E3, 0x6B8D, 0xD6DA, 0xEF9E, 0xEF7D, 0xD658, 0xC5D6, 0x4A28, 0x18A2, 0x18A2, 0xAD75, 0xFFFF, 0xFFFF, // 0x11D0 (4560)
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, // 0x11E0 (4576)
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, // 0x11F0 (4592)
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, // 0x1200 (4608)
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xEF7D, 0x528A, 0x0861, 0x0841, 0x1882, // 0x1210 (4624)
0x20E3, 0x2904, 0x18C3, 0x0841, 0x3186, 0xB596, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xBDD7, 0x3185, 0x41E7, // 0x1220 (4640)
0x39C7, 0x2924, 0x2904, 0x7C0F, 0xBCB1, 0xE3AA, 0xDAE8, 0xE4F2, 0xD679, 0xDEB9, 0xBD94, 0x2903, 0x18A2, 0x8410, 0xFFFF, 0xFFFF, // 0x1230 (4656)
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, // 0x1240 (4672)
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, // 0x1250 (4688)
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, // 0x1260 (4704)
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xB5B6, 0x6B4D, 0x4A28, // 0x1270 (4720)
0x39C6, 0x4207, 0x5ACA, 0x9CD3, 0xF7BE, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0x630C, 0x2924, 0x3986, // 0x1280 (4736)
0x2945, 0x20C3, 0x630B, 0xB554, 0x936C, 0xD100, 0xF1A1, 0xE120, 0xDBCC, 0xDF3C, 0xE6B9, 0x5AAA, 0x1061, 0x62EC, 0xFFFF, 0xFFFF, // 0x1290 (4752)
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, // 0x12A0 (4768)
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, // 0x12B0 (4784)
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, // 0x12C0 (4800)
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xF7DE, 0xFFFF, 0xFFFF, // 0x12D0 (4816)
0xF7BE, 0xFFDE, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xDEFB, 0x3165, 0x2944, 0x3165, // 0x12E0 (4832)
0x20E3, 0x4A8A, 0xD554, 0xC9C4, 0xB203, 0xDA02, 0xE1E1, 0xE9A2, 0xD9E3, 0xCD53, 0xCE58, 0x7BAD, 0x0841, 0x528A, 0xFFFF, 0xFFFF, // 0x12F0 (4848)
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, // 0x1300 (4864)
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, // 0x1310 (4880)
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, // 0x1320 (4896)
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xF7DE, 0xFFFF, 0xFFFF, // 0x1330 (4912)
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0x9CD3, 0x18C2, 0x3145, 0x2924, // 0x1340 (4928)
0x1882, 0x94D3, 0xFC4D, 0xF140, 0xF2A6, 0xE4CF, 0xCA66, 0xC982, 0xE1E3, 0xA3CD, 0xC637, 0x8C0F, 0x0820, 0x528A, 0xFFFF, 0xFFFF, // 0x1350 (4944)
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, // 0x1360 (4960)
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, // 0x1370 (4976)
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, // 0x1380 (4992)
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xF7DE, 0xFFFF, 0xFFFF, // 0x1390 (5008)
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0x6B4C, 0x1082, 0x2924, 0x20E3, // 0x13A0 (5024)
0x2945, 0xC5D6, 0xEA44, 0xF1A1, 0xE224, 0xE285, 0xE2C7, 0xB1C3, 0xB163, 0xB4F1, 0xDED9, 0x7B8D, 0x1041, 0x738E, 0xFFFF, 0xFFFF, // 0x13B0 (5040)
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, // 0x13C0 (5056)
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, // 0x13D0 (5072)
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, // 0x13E0 (5088)
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xF7DE, 0xFFFF, 0xFFFF, // 0x13F0 (5104)
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0x62EB, 0x1082, 0x2924, 0x20E3, // 0x1400 (5120)
0x41E7, 0xDE99, 0xDA24, 0xF1E1, 0xD9A2, 0xB962, 0xDA86, 0xA9C4, 0x99E5, 0xFF9D, 0xF77C, 0x4A48, 0x0841, 0xA514, 0xFFFF, 0xFFFF, // 0x1410 (5136)
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, // 0x1420 (5152)
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, // 0x1430 (5168)
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, // 0x1440 (5184)
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xF7DE, 0xFFFF, 0xFFFF, // 0x1450 (5200)
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0x62EB, 0x1082, 0x2124, 0x18C3, // 0x1460 (5216)
0x41E8, 0xDE99, 0xD246, 0xF1E2, 0xE9E2, 0xB9A3, 0x9162, 0x88C0, 0xCC90, 0xFFFF, 0xCE17, 0x2944, 0x2103, 0xD69A, 0xFFFF, 0xFFFF, // 0x1470 (5232)
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, // 0x1480 (5248)
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, // 0x1490 (5264)
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, // 0x14A0 (5280)
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xF7DE, 0xFFFF, 0xFFFF, // 0x14B0 (5296)
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0x738E, 0x1081, 0x2124, 0x18C2, // 0x14C0 (5312)
0x31A6, 0xD69A, 0xD328, 0xF180, 0xF1C1, 0xF202, 0xD141, 0xCB8B, 0xEFBD, 0xFFDD, 0x7BAD, 0x1081, 0x5ACB, 0xFFFF, 0xFFFF, 0xFFFF, // 0x14D0 (5328)
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, // 0x14E0 (5344)
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, // 0x14F0 (5360)
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, // 0x1500 (5376)
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xF7DE, 0xFFFF, 0xFFFF, 0xFFFF, // 0x1510 (5392)
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0x9492, 0x0861, 0x2104, 0x20E3, // 0x1520 (5408)
0x2924, 0xBE18, 0xE595, 0xC9E3, 0xCA44, 0xD182, 0xCB6A, 0xE75B, 0xFFFE, 0xBDD5, 0x3165, 0x18A2, 0xC5F7, 0xFFFF, 0xFFFF, 0xFFFF, // 0x1530 (5424)
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, // 0x1540 (5440)
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, // 0x1550 (5456)
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, // 0x1560 (5472)
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xF7DE, 0xFFFF, 0xFFFF, 0xFFFF, // 0x1570 (5488)
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xCE79, 0x10A2, 0x20E3, 0x2104, // 0x1580 (5504)
0x20E3, 0x7BCE, 0xDE58, 0xB40E, 0x83EF, 0xB513, 0xDF1A, 0xFFBD, 0xCE57, 0x4A48, 0x1061, 0x630C, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, // 0x1590 (5520)
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, // 0x15A0 (5536)
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, // 0x15B0 (5552)
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, // 0x15C0 (5568)
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xF7DE, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, // 0x15D0 (5584)
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0x4A49, 0x1081, 0x2103, // 0x15E0 (5600)
0x20E3, 0x3165, 0x9CB1, 0xBDB5, 0xAD14, 0xE71B, 0xE6FA, 0xB553, 0x5A89, 0x18A2, 0x39A6, 0xEF3C, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, // 0x15F0 (5616)
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, // 0x1600 (5632)
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, // 0x1610 (5648)
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, // 0x1620 (5664)
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xF7DE, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, // 0x1630 (5680)
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xCE38, 0x1082, 0x18A2, // 0x1640 (5696)
0x20E3, 0x2124, 0x39A6, 0x7B6D, 0x9450, 0x9450, 0x7B8E, 0x4207, 0x20C3, 0x2104, 0xD679, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, // 0x1650 (5712)
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, // 0x1660 (5728)
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, // 0x1670 (5744)
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, // 0x1680 (5760)
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xF7DE, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, // 0x1690 (5776)
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xA534, 0x18C3, // 0x16A0 (5792)
0x1082, 0x18C2, 0x2104, 0x3165, 0x39A6, 0x39A6, 0x2944, 0x1061, 0x3165, 0xC638, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, // 0x16B0 (5808)
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, // 0x16C0 (5824)
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, // 0x16D0 (5840)
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, // 0x16E0 (5856)
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xF7DE, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, // 0x16F0 (5872)
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFDF, 0xFFFF, 0xFFFF, 0xB5B6, // 0x1700 (5888)
0x4A28, 0x2104, 0x1061, 0x0820, 0x0820, 0x1061, 0x2944, 0x7BAE, 0xEF5C, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, // 0x1710 (5904)
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, // 0x1720 (5920)
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, // 0x1730 (5936)
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, // 0x1740 (5952)
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xF7DE, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, // 0x1750 (5968)
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, // 0x1760 (5984)
0xFFDF, 0xD6BA, 0xB596, 0x9CD3, 0x9CD3, 0xB596, 0xEF3C, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, // 0x1770 (6000)
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, // 0x1780 (6016)
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, // 0x1790 (6032)
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, // 0x17A0 (6048)
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xF7DE, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, // 0x17B0 (6064)
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, // 0x17C0 (6080)
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, // 0x17D0 (6096)
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, // 0x17E0 (6112)
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xF7DE, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, // 0x17F0 (6128)
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, // 0x1800 (6144)
};
libraries/MCUFRIEND_kbv/examples/drawBitmap_kbv/bitmap_mono.h
+343
View File
@@ -0,0 +1,343 @@
// http://skaarhoj.com/FreeStuff/GraphicDisplayImageConverter.php
// width x height = 64,64
static const uint8_t magnify_inv_64x64[] PROGMEM = {
0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
0xff,0xff,0xfc,0x03,0xff,0xff,0xff,0xff,
0xff,0xff,0xe0,0x00,0x7f,0xff,0xff,0xff,
0xff,0xff,0x80,0x00,0x1f,0xff,0xff,0xff,
0xff,0xff,0x00,0x00,0x0f,0xff,0xff,0xff,
0xff,0xfc,0x00,0x00,0x03,0xff,0xff,0xff,
0xff,0xf8,0x00,0x00,0x01,0xff,0xff,0xff,
0xff,0xf0,0x00,0x40,0x01,0xff,0xff,0xff,
0xff,0xf0,0x07,0xfe,0x00,0xff,0xff,0xff,
0xff,0xe0,0x0f,0xff,0x00,0x7f,0xff,0xff,
0xff,0xc0,0x3f,0xff,0xc0,0x7f,0xff,0xff,
0xff,0xc0,0x7f,0xff,0xc0,0x3f,0xff,0xff,
0xff,0xc0,0x7f,0xff,0xe0,0x3f,0xff,0xff,
0xff,0x80,0xff,0xff,0xf0,0x1f,0xff,0xff,
0xff,0x80,0xff,0xff,0xf0,0x1f,0xff,0xff,
0xff,0x81,0xff,0xff,0xf8,0x1f,0xff,0xff,
0xff,0x81,0xff,0xff,0xf8,0x1f,0xff,0xff,
0xff,0x01,0xff,0xff,0xf8,0x1f,0xff,0xff,
0xff,0x01,0xff,0xff,0xf8,0x1f,0xff,0xff,
0xff,0x01,0xff,0xff,0xf8,0x1f,0xff,0xff,
0xff,0x81,0xff,0xff,0xf8,0x1f,0xff,0xff,
0xff,0x81,0xff,0xff,0xf8,0x1f,0xff,0xff,
0xff,0x80,0xff,0xff,0xf0,0x1f,0xff,0xff,
0xff,0x80,0xff,0xff,0xf0,0x1f,0xff,0xff,
0xff,0x80,0x7f,0xff,0xe0,0x3f,0xff,0xff,
0xff,0xc0,0x7f,0xff,0xe0,0x3f,0xff,0xff,
0xff,0xc0,0x3f,0xff,0xc0,0x7f,0xff,0xff,
0xff,0xe0,0x1f,0xff,0x00,0x7f,0xff,0xff,
0xff,0xf0,0x07,0xfe,0x00,0x7f,0xff,0xff,
0xff,0xf0,0x00,0xf0,0x00,0x7f,0xff,0xff,
0xff,0xf8,0x00,0x00,0x00,0x3f,0xff,0xff,
0xff,0xfc,0x00,0x00,0x00,0x1f,0xff,0xff,
0xff,0xfe,0x00,0x00,0x00,0x0f,0xff,0xff,
0xff,0xff,0x80,0x00,0x10,0x07,0xff,0xff,
0xff,0xff,0xe0,0x00,0x78,0x03,0xff,0xff,
0xff,0xff,0xfc,0x03,0xfc,0x01,0xff,0xff,
0xff,0xff,0xff,0xff,0xfe,0x00,0xff,0xff,
0xff,0xff,0xff,0xff,0xff,0x00,0x7f,0xff,
0xff,0xff,0xff,0xff,0xff,0x80,0x3f,0xff,
0xff,0xff,0xff,0xff,0xff,0xc0,0x1f,0xff,
0xff,0xff,0xff,0xff,0xff,0xe0,0x0f,0xff,
0xff,0xff,0xff,0xff,0xff,0xf0,0x07,0xff,
0xff,0xff,0xff,0xff,0xff,0xf8,0x03,0xff,
0xff,0xff,0xff,0xff,0xff,0xfc,0x01,0xff,
0xff,0xff,0xff,0xff,0xff,0xfe,0x00,0xff,
0xff,0xff,0xff,0xff,0xff,0xff,0x00,0x7f,
0xff,0xff,0xff,0xff,0xff,0xff,0x80,0x3f,
0xff,0xff,0xff,0xff,0xff,0xff,0xc0,0x7f,
0xff,0xff,0xff,0xff,0xff,0xff,0xe0,0xff,
0xff,0xff,0xff,0xff,0xff,0xff,0xf1,0xff,
0xff,0xff,0xff,0xff,0xff,0xff,0xfb,0xff,
0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
};
// width x height = 64,64
static const uint8_t magnify_64x64[] PROGMEM = {
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x03,0xfc,0x00,0x00,0x00,0x00,
0x00,0x00,0x1f,0xff,0x80,0x00,0x00,0x00,
0x00,0x00,0x7f,0xff,0xe0,0x00,0x00,0x00,
0x00,0x00,0xff,0xff,0xf0,0x00,0x00,0x00,
0x00,0x03,0xff,0xff,0xfc,0x00,0x00,0x00,
0x00,0x07,0xff,0xff,0xfe,0x00,0x00,0x00,
0x00,0x0f,0xff,0xbf,0xfe,0x00,0x00,0x00,
0x00,0x0f,0xf8,0x01,0xff,0x00,0x00,0x00,
0x00,0x1f,0xf0,0x00,0xff,0x80,0x00,0x00,
0x00,0x3f,0xc0,0x00,0x3f,0x80,0x00,0x00,
0x00,0x3f,0x80,0x00,0x3f,0xc0,0x00,0x00,
0x00,0x3f,0x80,0x00,0x1f,0xc0,0x00,0x00,
0x00,0x7f,0x00,0x00,0x0f,0xe0,0x00,0x00,
0x00,0x7f,0x00,0x00,0x0f,0xe0,0x00,0x00,
0x00,0x7e,0x00,0x00,0x07,0xe0,0x00,0x00,
0x00,0x7e,0x00,0x00,0x07,0xe0,0x00,0x00,
0x00,0xfe,0x00,0x00,0x07,0xe0,0x00,0x00,
0x00,0xfe,0x00,0x00,0x07,0xe0,0x00,0x00,
0x00,0xfe,0x00,0x00,0x07,0xe0,0x00,0x00,
0x00,0x7e,0x00,0x00,0x07,0xe0,0x00,0x00,
0x00,0x7e,0x00,0x00,0x07,0xe0,0x00,0x00,
0x00,0x7f,0x00,0x00,0x0f,0xe0,0x00,0x00,
0x00,0x7f,0x00,0x00,0x0f,0xe0,0x00,0x00,
0x00,0x7f,0x80,0x00,0x1f,0xc0,0x00,0x00,
0x00,0x3f,0x80,0x00,0x1f,0xc0,0x00,0x00,
0x00,0x3f,0xc0,0x00,0x3f,0x80,0x00,0x00,
0x00,0x1f,0xe0,0x00,0xff,0x80,0x00,0x00,
0x00,0x0f,0xf8,0x01,0xff,0x80,0x00,0x00,
0x00,0x0f,0xff,0x0f,0xff,0x80,0x00,0x00,
0x00,0x07,0xff,0xff,0xff,0xc0,0x00,0x00,
0x00,0x03,0xff,0xff,0xff,0xe0,0x00,0x00,
0x00,0x01,0xff,0xff,0xff,0xf0,0x00,0x00,
0x00,0x00,0x7f,0xff,0xef,0xf8,0x00,0x00,
0x00,0x00,0x1f,0xff,0x87,0xfc,0x00,0x00,
0x00,0x00,0x03,0xfc,0x03,0xfe,0x00,0x00,
0x00,0x00,0x00,0x00,0x01,0xff,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0xff,0x80,0x00,
0x00,0x00,0x00,0x00,0x00,0x7f,0xc0,0x00,
0x00,0x00,0x00,0x00,0x00,0x3f,0xe0,0x00,
0x00,0x00,0x00,0x00,0x00,0x1f,0xf0,0x00,
0x00,0x00,0x00,0x00,0x00,0x0f,0xf8,0x00,
0x00,0x00,0x00,0x00,0x00,0x07,0xfc,0x00,
0x00,0x00,0x00,0x00,0x00,0x03,0xfe,0x00,
0x00,0x00,0x00,0x00,0x00,0x01,0xff,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0xff,0x80,
0x00,0x00,0x00,0x00,0x00,0x00,0x7f,0xc0,
0x00,0x00,0x00,0x00,0x00,0x00,0x3f,0x80,
0x00,0x00,0x00,0x00,0x00,0x00,0x1f,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x0e,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x04,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
};
// width x height = 96,64 (768 bytes)
static const uint8_t camera_96x64[] PROGMEM = {
0xff,0xff,0xff,0xff,0xf0,0x00,0x00,0x0f,0xff,0xff,0xff,0xff,
0xff,0xff,0xff,0xff,0xe0,0x00,0x00,0x07,0xff,0xff,0xff,0xff,
0xff,0xff,0xff,0xff,0xc0,0x00,0x00,0x03,0xff,0xff,0xff,0xff,
0xff,0xff,0xff,0xff,0x80,0x00,0x00,0x01,0xff,0x00,0x0f,0xff,
0xff,0xff,0xff,0xff,0x00,0x00,0x00,0x00,0xff,0x00,0x0f,0xff,
0xff,0xff,0xff,0xfe,0x00,0x00,0x00,0x00,0x7f,0x00,0x0f,0xff,
0x00,0x00,0x00,0x00,0x01,0xff,0xff,0x80,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x07,0xff,0xff,0xe0,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x0f,0xff,0xff,0xf0,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x1f,0xff,0xff,0xf8,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x3f,0xff,0xff,0xfc,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x7f,0xff,0xff,0xfe,0x00,0x00,0x00,0x00,
0x03,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xc0,
0x03,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xc0,
0x03,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xc0,
0x03,0xf0,0x3f,0xff,0xff,0xfc,0x3f,0xff,0xff,0xff,0xff,0xc0,
0x03,0xf0,0x3f,0xff,0xff,0xc0,0x03,0xff,0xff,0xff,0xff,0xc0,
0x03,0xf0,0x3f,0xff,0xff,0x00,0x00,0xff,0xff,0xff,0xff,0xc0,
0x03,0xf0,0x3f,0xff,0xfc,0x00,0x00,0x3f,0xff,0xff,0xff,0xc0,
0x03,0xf0,0x3f,0xff,0xf8,0x00,0x00,0x1f,0xff,0xff,0xff,0xc0,
0x03,0xf0,0x3f,0xff,0xf0,0x00,0x00,0x0f,0xff,0xff,0xff,0xc0,
0x03,0xf0,0x7f,0xff,0xe0,0x00,0x00,0x07,0xff,0xff,0xff,0xc0,
0x03,0xff,0xff,0xff,0xc0,0x1f,0xf8,0x03,0xff,0xff,0xff,0xc0,
0x03,0xff,0xff,0xff,0x80,0x3f,0xfc,0x01,0xff,0xff,0xff,0xc0,
0x01,0xff,0xff,0xff,0x00,0xff,0xff,0x00,0xff,0xff,0xff,0x80,
0x00,0x00,0x00,0x00,0x01,0xff,0xff,0x80,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x03,0xff,0xff,0xc0,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x03,0xff,0xff,0xc0,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x07,0xff,0xff,0xe0,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x07,0xff,0xff,0xe0,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x0f,0xff,0xff,0xf0,0x00,0x00,0x00,0x00,
0x03,0xff,0xff,0xfc,0x0f,0xff,0xff,0xf0,0x3f,0xff,0xff,0xc0,
0x03,0xff,0xff,0xfc,0x0f,0xff,0xff,0xf0,0x3f,0xff,0xff,0xc0,
0x03,0xff,0xff,0xfc,0x0f,0xff,0xff,0xf0,0x3f,0xff,0xff,0xc0,
0x03,0xff,0xff,0xfc,0x0f,0xff,0xff,0xf0,0x3f,0xff,0xff,0xc0,
0x03,0xff,0xff,0xfc,0x0f,0xff,0xff,0xf0,0x3f,0xff,0xff,0xc0,
0x03,0xff,0xff,0xfc,0x0f,0xff,0xff,0xf0,0x3f,0xff,0xff,0xc0,
0x03,0xff,0xff,0xfc,0x07,0xff,0xff,0xe0,0x3f,0xff,0xff,0xc0,
0x03,0xff,0xff,0xfe,0x07,0xff,0xff,0xe0,0x7f,0xff,0xff,0xc0,
0x03,0xff,0xff,0xfe,0x03,0xff,0xff,0xc0,0x7f,0xff,0xff,0xc0,
0x03,0xff,0xff,0xfe,0x03,0xff,0xff,0xc0,0x7f,0xff,0xff,0xc0,
0x03,0xff,0xff,0xff,0x01,0xff,0xff,0x80,0xff,0xff,0xff,0xc0,
0x03,0xff,0xff,0xff,0x00,0xff,0xff,0x00,0xff,0xff,0xff,0xc0,
0x03,0xff,0xff,0xff,0x80,0x7f,0xfe,0x01,0xff,0xff,0xff,0xc0,
0x03,0xff,0xff,0xff,0x80,0x1f,0xf8,0x01,0xff,0xff,0xff,0xc0,
0x03,0xff,0xff,0xff,0xc0,0x03,0xc0,0x03,0xff,0xff,0xff,0xc0,
0x03,0xff,0xff,0xff,0xe0,0x00,0x00,0x07,0xff,0xff,0xff,0xc0,
0x03,0xff,0xff,0xff,0xf0,0x00,0x00,0x0f,0xff,0xff,0xff,0xc0,
0x03,0xff,0xff,0xff,0xf8,0x00,0x00,0x1f,0xff,0xff,0xff,0xc0,
0x03,0xff,0xff,0xff,0xfe,0x00,0x00,0x7f,0xff,0xff,0xff,0xc0,
0x03,0xff,0xff,0xff,0xff,0x80,0x01,0xff,0xff,0xff,0xff,0xc0,
0x03,0xff,0xff,0xff,0xff,0xf0,0x0f,0xff,0xff,0xff,0xff,0xc0,
0x03,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xc0,
0x03,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xc0,
0x03,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xc0,
0x03,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xc0,
0x03,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xc0,
0x03,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xc0,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
};
// width x height = 96,64
static const uint8_t camera_inv_96x64[] PROGMEM = {
0x00,0x00,0x00,0x00,0x0f,0xff,0xff,0xf0,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x1f,0xff,0xff,0xf8,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x3f,0xff,0xff,0xfc,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x7f,0xff,0xff,0xfe,0x00,0xff,0xf0,0x00,
0x00,0x00,0x00,0x00,0xff,0xff,0xff,0xff,0x00,0xff,0xf0,0x00,
0x00,0x00,0x00,0x01,0xff,0xff,0xff,0xff,0x80,0xff,0xf0,0x00,
0xff,0xff,0xff,0xff,0xfe,0x00,0x00,0x7f,0xff,0xff,0xff,0xff,
0xff,0xff,0xff,0xff,0xf8,0x00,0x00,0x1f,0xff,0xff,0xff,0xff,
0xff,0xff,0xff,0xff,0xf0,0x00,0x00,0x0f,0xff,0xff,0xff,0xff,
0xff,0xff,0xff,0xff,0xe0,0x00,0x00,0x07,0xff,0xff,0xff,0xff,
0xff,0xff,0xff,0xff,0xc0,0x00,0x00,0x03,0xff,0xff,0xff,0xff,
0xff,0xff,0xff,0xff,0x80,0x00,0x00,0x01,0xff,0xff,0xff,0xff,
0xfc,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x3f,
0xfc,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x3f,
0xfc,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x3f,
0xfc,0x0f,0xc0,0x00,0x00,0x03,0xc0,0x00,0x00,0x00,0x00,0x3f,
0xfc,0x0f,0xc0,0x00,0x00,0x3f,0xfc,0x00,0x00,0x00,0x00,0x3f,
0xfc,0x0f,0xc0,0x00,0x00,0xff,0xff,0x00,0x00,0x00,0x00,0x3f,
0xfc,0x0f,0xc0,0x00,0x03,0xff,0xff,0xc0,0x00,0x00,0x00,0x3f,
0xfc,0x0f,0xc0,0x00,0x07,0xff,0xff,0xe0,0x00,0x00,0x00,0x3f,
0xfc,0x0f,0xc0,0x00,0x0f,0xff,0xff,0xf0,0x00,0x00,0x00,0x3f,
0xfc,0x0f,0x80,0x00,0x1f,0xff,0xff,0xf8,0x00,0x00,0x00,0x3f,
0xfc,0x00,0x00,0x00,0x3f,0xe0,0x07,0xfc,0x00,0x00,0x00,0x3f,
0xfc,0x00,0x00,0x00,0x7f,0xc0,0x03,0xfe,0x00,0x00,0x00,0x3f,
0xfe,0x00,0x00,0x00,0xff,0x00,0x00,0xff,0x00,0x00,0x00,0x7f,
0xff,0xff,0xff,0xff,0xfe,0x00,0x00,0x7f,0xff,0xff,0xff,0xff,
0xff,0xff,0xff,0xff,0xfc,0x00,0x00,0x3f,0xff,0xff,0xff,0xff,
0xff,0xff,0xff,0xff,0xfc,0x00,0x00,0x3f,0xff,0xff,0xff,0xff,
0xff,0xff,0xff,0xff,0xf8,0x00,0x00,0x1f,0xff,0xff,0xff,0xff,
0xff,0xff,0xff,0xff,0xf8,0x00,0x00,0x1f,0xff,0xff,0xff,0xff,
0xff,0xff,0xff,0xff,0xf0,0x00,0x00,0x0f,0xff,0xff,0xff,0xff,
0xfc,0x00,0x00,0x03,0xf0,0x00,0x00,0x0f,0xc0,0x00,0x00,0x3f,
0xfc,0x00,0x00,0x03,0xf0,0x00,0x00,0x0f,0xc0,0x00,0x00,0x3f,
0xfc,0x00,0x00,0x03,0xf0,0x00,0x00,0x0f,0xc0,0x00,0x00,0x3f,
0xfc,0x00,0x00,0x03,0xf0,0x00,0x00,0x0f,0xc0,0x00,0x00,0x3f,
0xfc,0x00,0x00,0x03,0xf0,0x00,0x00,0x0f,0xc0,0x00,0x00,0x3f,
0xfc,0x00,0x00,0x03,0xf0,0x00,0x00,0x0f,0xc0,0x00,0x00,0x3f,
0xfc,0x00,0x00,0x03,0xf8,0x00,0x00,0x1f,0xc0,0x00,0x00,0x3f,
0xfc,0x00,0x00,0x01,0xf8,0x00,0x00,0x1f,0x80,0x00,0x00,0x3f,
0xfc,0x00,0x00,0x01,0xfc,0x00,0x00,0x3f,0x80,0x00,0x00,0x3f,
0xfc,0x00,0x00,0x01,0xfc,0x00,0x00,0x3f,0x80,0x00,0x00,0x3f,
0xfc,0x00,0x00,0x00,0xfe,0x00,0x00,0x7f,0x00,0x00,0x00,0x3f,
0xfc,0x00,0x00,0x00,0xff,0x00,0x00,0xff,0x00,0x00,0x00,0x3f,
0xfc,0x00,0x00,0x00,0x7f,0x80,0x01,0xfe,0x00,0x00,0x00,0x3f,
0xfc,0x00,0x00,0x00,0x7f,0xe0,0x07,0xfe,0x00,0x00,0x00,0x3f,
0xfc,0x00,0x00,0x00,0x3f,0xfc,0x3f,0xfc,0x00,0x00,0x00,0x3f,
0xfc,0x00,0x00,0x00,0x1f,0xff,0xff,0xf8,0x00,0x00,0x00,0x3f,
0xfc,0x00,0x00,0x00,0x0f,0xff,0xff,0xf0,0x00,0x00,0x00,0x3f,
0xfc,0x00,0x00,0x00,0x07,0xff,0xff,0xe0,0x00,0x00,0x00,0x3f,
0xfc,0x00,0x00,0x00,0x01,0xff,0xff,0x80,0x00,0x00,0x00,0x3f,
0xfc,0x00,0x00,0x00,0x00,0x7f,0xfe,0x00,0x00,0x00,0x00,0x3f,
0xfc,0x00,0x00,0x00,0x00,0x0f,0xf0,0x00,0x00,0x00,0x00,0x3f,
0xfc,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x3f,
0xfc,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x3f,
0xfc,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x3f,
0xfc,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x3f,
0xfc,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x3f,
0xfc,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x3f,
0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
};
// width x height = 128,64 (1024 bytes)
static const uint8_t tractor_128x64[] PROGMEM = {
0x00,0x00,0x00,0x00,0x10,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x7c,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x44,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x64,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x6c,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x6c,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x6c,0x00,0x00,0x00,0x1f,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x6c,0x00,0x00,0x00,0x31,0xc0,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x6c,0x00,0x00,0x00,0x28,0x70,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x6c,0x00,0x00,0x00,0x24,0x10,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x6c,0x00,0x00,0x00,0x23,0x38,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x6c,0x00,0x00,0x00,0x23,0xec,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x6c,0x00,0x00,0x00,0x1f,0x84,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x03,0xf8,0x7c,0x00,0x00,0x00,0x1b,0x84,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x0f,0xff,0xff,0xfc,0x00,0x00,0x0e,0x44,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x1c,0x80,0x00,0x1f,0xff,0xfc,0x06,0x2e,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x39,0x00,0x00,0x00,0x30,0x1e,0x6f,0x9f,0xc0,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x39,0x00,0x00,0x00,0x00,0x01,0xfc,0xff,0xe0,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x79,0x00,0x09,0x00,0x08,0x00,0xf8,0xff,0x80,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0xf9,0x80,0xf0,0x12,0x4a,0x22,0xf1,0xfe,0x07,0x00,0x00,0x00,0x00,0x00,
0x00,0x01,0x7c,0x04,0x28,0x00,0x08,0x00,0xf3,0xf3,0xfd,0xc0,0x00,0x00,0x00,0x00,
0x00,0x01,0x7f,0xf2,0x09,0xff,0xc8,0x00,0xf3,0xf0,0x0c,0xf0,0x00,0x00,0x00,0x00,
0x00,0x01,0x7c,0x01,0x2f,0xff,0xef,0xff,0x67,0xeb,0xe4,0x78,0x00,0x00,0x00,0x00,
0x00,0x01,0xff,0xfd,0xbf,0xff,0xc0,0x00,0x7f,0x0f,0xe0,0x38,0x00,0x00,0x00,0x00,
0x00,0x00,0x7f,0xfd,0x7f,0xff,0xcf,0xff,0xff,0x90,0x20,0x1c,0x00,0x00,0x00,0x00,
0x00,0x00,0x3c,0x01,0x3f,0xff,0xef,0xff,0xff,0x81,0x00,0x0e,0x00,0x00,0x00,0x00,
0x00,0x00,0x3f,0xfd,0x3c,0x03,0xef,0xff,0xff,0x67,0x0f,0xce,0x00,0x00,0x00,0x00,
0x00,0x00,0x7f,0xfc,0x3f,0xff,0xef,0xf0,0xfc,0x5f,0x9f,0xe6,0x00,0x00,0x00,0x00,
0x00,0x00,0x1c,0x00,0x3f,0xff,0xef,0xc1,0x3c,0x70,0x3f,0xe7,0x00,0x00,0x00,0x00,
0x00,0x00,0x3f,0xfc,0x3f,0xff,0xff,0x87,0xbe,0xc0,0x70,0x73,0x80,0x00,0x00,0x00,
0x00,0x00,0x3f,0xfc,0xbf,0xff,0xff,0x87,0xde,0x00,0x67,0xb3,0x00,0x00,0x00,0x00,
0x00,0x00,0x1c,0x00,0x9b,0x80,0xe0,0x07,0xdc,0x0e,0xef,0xdf,0x00,0x00,0x00,0x00,
0x00,0x00,0x1c,0x00,0x83,0x80,0xe0,0x07,0x59,0xbc,0xdf,0xef,0x00,0x00,0x00,0x00,
0x00,0x00,0x3f,0xfc,0x93,0xc0,0xe0,0x77,0x50,0x70,0xe1,0xef,0x00,0x00,0x00,0x00,
0x00,0x00,0x1c,0x00,0x9f,0xff,0xe0,0x77,0xd8,0xe0,0x80,0xdf,0x80,0x00,0x00,0x00,
0x00,0x00,0x5f,0xe0,0x9f,0xff,0xe0,0x7a,0xd9,0x80,0x80,0xd7,0xc0,0x00,0x00,0x00,
0x00,0x01,0xbf,0xfc,0x9f,0xff,0xe0,0xfa,0xbd,0x08,0x80,0xd7,0x80,0x00,0x00,0x00,
0x00,0x02,0xfc,0x00,0x1f,0xe0,0xf3,0xfc,0x7c,0x1c,0x80,0x77,0x80,0x00,0x00,0x00,
0x00,0x05,0x3f,0xff,0xdf,0xb0,0x37,0xff,0xf2,0xb8,0x00,0x7f,0x80,0x00,0x00,0x00,
0x00,0x0a,0x7c,0x00,0x03,0x40,0x1f,0xff,0xf1,0xf0,0x04,0x6f,0x80,0x00,0x00,0x00,
0x00,0x14,0xfe,0x00,0x06,0x90,0x0f,0xff,0xf1,0x60,0x06,0x6f,0x80,0x00,0x00,0x00,
0x00,0x15,0xff,0x00,0x0d,0x07,0x8f,0xfe,0xf0,0xc0,0x04,0x63,0xc0,0x00,0x00,0x00,
0x00,0x2b,0xff,0xff,0xfc,0x4f,0xc7,0xf9,0xf9,0x80,0x04,0x77,0xc0,0x00,0x00,0x00,
0x00,0x2b,0x9f,0xff,0xfa,0x98,0x67,0xc7,0xfd,0x0c,0x40,0x77,0x80,0x00,0x00,0x00,
0x00,0x27,0x1f,0xff,0xfa,0xb7,0x34,0x3f,0xfe,0x1c,0x00,0xf7,0x80,0x00,0x00,0x00,
0x00,0x37,0x01,0xff,0xf8,0x2f,0xb3,0xff,0xfa,0x3c,0x00,0xd7,0x80,0x00,0x00,0x00,
0x00,0x37,0x00,0xff,0x9c,0x39,0xdb,0xff,0xf9,0x3c,0x00,0xc7,0x80,0x00,0x00,0x00,
0x00,0x36,0x1c,0xff,0x9c,0x20,0xdb,0xff,0xfc,0x78,0x21,0xaf,0x80,0x00,0x00,0x00,
0x00,0x36,0x1e,0x3f,0x9c,0x40,0xdb,0xff,0xfe,0xf0,0x13,0x0f,0x80,0x00,0x00,0x00,
0x00,0x36,0x1f,0xff,0x9c,0x42,0x5b,0xff,0xe6,0xf2,0x1e,0x5f,0x00,0x00,0x00,0x00,
0x00,0x36,0x1f,0xff,0xfc,0x41,0x5b,0xff,0xc3,0x67,0x00,0x1e,0x00,0x00,0x00,0x00,
0x00,0x26,0x1f,0xff,0xfc,0x0f,0x5b,0xff,0xc7,0xee,0x00,0x37,0x00,0x00,0x00,0x00,
0x00,0x27,0x02,0xff,0xfd,0x0e,0x5b,0xff,0xc3,0xfe,0x07,0xe7,0x00,0x00,0x00,0x00,
0x00,0x37,0x44,0xe0,0x1d,0x00,0xd7,0xff,0x81,0xfc,0xc3,0xc6,0x00,0x00,0x00,0x00,
0x00,0x1b,0x38,0xe0,0x19,0x00,0x97,0xff,0x80,0xfc,0xc0,0x0c,0x00,0x00,0x00,0x00,
0x00,0x13,0x81,0xe0,0x1b,0x20,0xb7,0xff,0x00,0xfd,0x80,0x18,0x00,0x00,0x00,0x00,
0x00,0x1b,0xc3,0xc0,0x0a,0x33,0x27,0xff,0xfc,0xff,0x90,0x3f,0xe0,0x00,0x00,0x00,
0x00,0x0f,0xff,0xc0,0x0e,0x1e,0x6f,0xff,0xff,0xff,0xb8,0xff,0xe0,0x00,0x00,0x00,
0x00,0x3f,0xff,0x80,0x0d,0x98,0xcf,0xff,0xff,0xff,0xff,0xff,0x80,0x00,0x00,0x00,
0x03,0xff,0xff,0xff,0xfd,0x8f,0x9f,0xf8,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x7f,0xff,0xff,0xff,0xff,0xc0,0x38,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x0f,0xff,0xff,0x83,0xff,0xc0,0x70,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x07,0xe0,0xc0,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x3f,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
};
libraries/MCUFRIEND_kbv/examples/drawBitmap_kbv/drawBitmap_kbv.ino
+160
View File
@@ -0,0 +1,160 @@
#include "MCUFRIEND_kbv.h"
MCUFRIEND_kbv tft;
#define LOWFLASH (defined(__AVR_ATmega328P__) && defined(MCUFRIEND_KBV_H_))
#include "bitmap_mono.h"
#include "bitmap_RGB.h"
#define BLACK 0x0000
#define BLUE 0x001F
#define RED 0xF800
#define GREEN 0x07E0
#define CYAN 0x07FF
#define MAGENTA 0xF81F
#define YELLOW 0xFFE0
#define WHITE 0xFFFF
#define GREY 0x8410
#define ORANGE 0xE880
void setup()
{
Serial.begin(9600);
uint16_t ID = tft.readID();
Serial.print(F("ID = 0x"));
Serial.println(ID, HEX);
Serial.println(F("GFX drawBitmap() plots one mono pixel at a time"));
Serial.println(F("it defaults to transparent plotting"));
Serial.println(F("unless you specify foreground and background colours"));
Serial.println(F("it can plot a monochrome bitmap from Flash or SRAM"));
Serial.println(F(""));
Serial.println(F("GFX drawGrayscaleBitmap() is not relevant for OLED, TFT"));
Serial.println(F("GFX drawRGBBitmap() plots one colour pixel at a time"));
Serial.println(F("from Flash or SRAM and with a monochrome transparent bitmask"));
Serial.println(F(""));
Serial.println(F("Using the hardware pushColors() methods is faster"));
Serial.println(F("pushColors() expects uint16 array in SRAM"));
Serial.println(F("for any runtime generated images"));
Serial.println(F("but it expects uint8_t array of serialised bytes in Flash"));
Serial.println(F(""));
Serial.println(F("Colour TFTs are natively big-endian"));
Serial.println(F("Many microcontrollers and Tools are little-endian"));
Serial.println(F("you can use the optional argument to select big-end"));
tft.begin(ID);
// invertmap(betty_1_bmp + 62, 8960);
// while (1);
}
// GFX drawBitmap() expects each row to be on 8-bit boundary. i.e. pad = 7
// Mono BMP rows are on 32-bit boundary. i.e. pad = 31, rows are in RVS order.
// FreeFont bitmaps have no padding. i.e. pad = 0. e.g. 5x4 bitmap is in 3 bytes
void showbgd(int x, int y, const uint8_t *bmp, int w, int h, uint16_t color, uint16_t bg, uint8_t pad = 7)
{
int yy, xx;
uint8_t first = 1, RVS = pad & 0x80;
uint16_t pixel;
pad &= 31;
uint16_t wid = (w + pad) & ~pad; //bits per row
tft.setAddrWindow(x, y, x + w - 1, y + h - 1); //
for (yy = 0; yy < h; yy++) {
uint32_t ofs = (RVS ? (h - yy - 1) : yy) * wid; //bit offset
const uint8_t *p = bmp + (ofs >> 3); //flash address
uint8_t mask = 0x80 >> (ofs & 7); //bit mask
uint8_t c = pgm_read_byte(p++);
for (xx = 0; xx < w; xx++) {
if (mask == 0) {
c = pgm_read_byte(p++);
mask = 0x80;
}
pixel = (c & mask) ? color : bg;
tft.pushColors(&pixel, 1, first);
first = 0;
mask >>= 1;
}
}
tft.setAddrWindow(0, 0, tft.width() - 1, tft.height() - 1);
}
void msg_time(int x, int y, String msg, uint32_t t)
{
t = millis() - t;
tft.setCursor(x, y);
tft.print(msg);
tft.print(t);
tft.print(F("ms"));
}
void loop(void)
{
int x = 5, y, w = 128, h = 64;
uint32_t t;
const int SZ = w * h / 8;
uint8_t sram[SZ];
memcpy_P(sram, tractor_128x64, SZ);
tft.fillScreen(BLACK);
y = 0; t = millis();
tft.drawBitmap(x, y, tractor_128x64, 128, 64, BLUE);
msg_time(0, y + 66, F("drawBitmap() transparent flash "), t);
y = 80; t = millis();
tft.drawBitmap(x, y, tractor_128x64, 128, 64, RED, YELLOW);
msg_time(0, y + 66, F("drawBitmap() background flash "), t);
y = 160; t = millis();
tft.fillRect(x, y, w, h, GREY);
tft.drawBitmap(x, y, sram, 128, 64, GREEN);
msg_time(0, y + 66, F("drawBitmap() fill bgd SRAM "), t);
y = 240; t = millis();
showbgd(x, y, tractor_128x64, 128, 64, MAGENTA, YELLOW);
msg_time(0, y + 66, F("pushColors() background flash "), t);
delay(5000);
tft.fillScreen(BLACK);
y = 0; t = millis();
tft.drawRGBBitmap(x, y, marilyn_64x64, 64, 64);
msg_time(0, y + 66, "drawRGBBitmap() flash ", t);
y = 80; t = millis();
tft.setAddrWindow(x, y, x + 64 - 1, y + 64 - 1);
tft.pushColors((const uint8_t*)marilyn_64x64, 64 * 64, 1, false);
tft.setAddrWindow(0, 0, tft.width() - 1, tft.height() - 1);
msg_time(0, y + 66, F("pushColors() flash "), t);
y = 160; t = millis();
w = 64;
tft.fillRect(x, y, w, h, GREY);
tft.drawRGBBitmap(x, y, marilyn_64x64, magnify_64x64, 64, 64);
msg_time(0, y + 66, F("drawRGBBitmap() with mask "), t);
y = 240; t = millis();
w = 64;
tft.fillRect(x, y, w, h, GREY);
tft.drawRGBBitmap(x, y, marilyn_64x64, magnify_inv_64x64, 64, 64);
msg_time(0, y + 66, F("drawRGBBitmap() with mask "), t);
delay(5000);
#if !LOWFLASH
tft.fillScreen(BLACK);
y = 0; t = millis();
tft.drawRGBBitmap(x, y, tractor10_96x64, 96, 64);
msg_time(0, y + 66, "drawRGBBitmap() flash ", t);
y = 80; t = millis();
tft.setAddrWindow(x, y, x + 96 - 1, y + 64 - 1);
tft.pushColors((const uint8_t*)tractor10_96x64, 96 * 64, 1, false);
tft.setAddrWindow(0, 0, tft.width() - 1, tft.height() - 1);
msg_time(0, y + 66, F("pushColors() flash "), t);
y = 160; t = millis();
w = 96;
tft.fillRect(x, y, w, h, GREY);
tft.drawRGBBitmap(x, y, tractor10_96x64, camera_96x64, 96, 64);
msg_time(0, y + 66, F("drawRGBBitmap() with mask "), t);
y = 240; t = millis();
w = 96;
tft.fillRect(x, y, w, h, GREY);
tft.drawRGBBitmap(x, y, tractor10_96x64, camera_inv_96x64, 96, 64);
msg_time(0, y + 66, F("drawRGBBitmap() with mask "), t);
delay(5000);
#endif
}
libraries/MCUFRIEND_kbv/examples/graphictest_kbv/graphictest_kbv.ino
+586
View File
@@ -0,0 +1,586 @@
// All the mcufriend.com UNO shields have the same pinout.
// i.e. control pins A0-A4. Data D2-D9. microSD D10-D13.
// Touchscreens are normally A1, A2, D7, D6 but the order varies
//
// This demo should work with most Adafruit TFT libraries
// If you are not using a shield, use a full Adafruit constructor()
// e.g. Adafruit_TFTLCD tft(LCD_CS, LCD_CD, LCD_WR, LCD_RD, LCD_RESET);
#define LCD_CS A3 // Chip Select goes to Analog 3
#define LCD_CD A2 // Command/Data goes to Analog 2
#define LCD_WR A1 // LCD Write goes to Analog 1
#define LCD_RD A0 // LCD Read goes to Analog 0
#define LCD_RESET A4 // Can alternately just connect to Arduino's reset pin
#include <SPI.h> // f.k. for Arduino-1.5.2
#include "Adafruit_GFX.h"// Hardware-specific library
#include <MCUFRIEND_kbv.h>
MCUFRIEND_kbv tft;
//#include <Adafruit_TFTLCD.h>
//Adafruit_TFTLCD tft(LCD_CS, LCD_CD, LCD_WR, LCD_RD, LCD_RESET);
// Assign human-readable names to some common 16-bit color values:
#define BLACK 0x0000
#define BLUE 0x001F
#define RED 0xF800
#define GREEN 0x07E0
#define CYAN 0x07FF
#define MAGENTA 0xF81F
#define YELLOW 0xFFE0
#define WHITE 0xFFFF
#ifndef min
#define min(a, b) (((a) < (b)) ? (a) : (b))
#endif
void setup(void);
void loop(void);
unsigned long testFillScreen();
unsigned long testText();
unsigned long testLines(uint16_t color);
unsigned long testFastLines(uint16_t color1, uint16_t color2);
unsigned long testRects(uint16_t color);
unsigned long testFilledRects(uint16_t color1, uint16_t color2);
unsigned long testFilledCircles(uint8_t radius, uint16_t color);
unsigned long testCircles(uint8_t radius, uint16_t color);
unsigned long testTriangles();
unsigned long testFilledTriangles();
unsigned long testRoundRects();
unsigned long testFilledRoundRects();
void progmemPrint(const char *str);
void progmemPrintln(const char *str);
void runtests(void);
uint16_t g_identifier;
extern const uint8_t hanzi[];
void showhanzi(unsigned int x, unsigned int y, unsigned char index)
{
uint8_t i, j, c, first = 1;
uint8_t *temp = (uint8_t*)hanzi;
uint16_t color;
tft.setAddrWindow(x, y, x + 31, y + 31); //设置区域
temp += index * 128;
for (j = 0; j < 128; j++)
{
c = pgm_read_byte(temp);
for (i = 0; i < 8; i++)
{
if ((c & (1 << i)) != 0)
{
color = RED;
}
else
{
color = BLACK;
}
tft.pushColors(&color, 1, first);
first = 0;
}
temp++;
}
}
void setup(void) {
Serial.begin(9600);
uint32_t when = millis();
// while (!Serial) ; //hangs a Leonardo until you connect a Serial
if (!Serial) delay(5000); //allow some time for Leonardo
Serial.println("Serial took " + String((millis() - when)) + "ms to start");
// tft.reset(); //hardware reset
uint16_t ID = tft.readID(); //
Serial.print("ID = 0x");
Serial.println(ID, HEX);
if (ID == 0xD3D3) ID = 0x9481; // write-only shield
// ID = 0x9329; // force ID
tft.begin(ID);
}
#if defined(MCUFRIEND_KBV_H_)
uint16_t scrollbuf[320]; // my biggest screen is 320x480
#define READGRAM(x, y, buf, w, h) tft.readGRAM(x, y, buf, w, h)
#else
uint16_t scrollbuf[320]; // Adafruit only does 240x320
// Adafruit can read a block by one pixel at a time
int16_t READGRAM(int16_t x, int16_t y, uint16_t *block, int16_t w, int16_t h)
{
uint16_t *p;
for (int row = 0; row < h; row++) {
p = block + row * w;
for (int col = 0; col < w; col++) {
*p++ = tft.readPixel(x + col, y + row);
}
}
}
#endif
void windowScroll(int16_t x, int16_t y, int16_t wid, int16_t ht, int16_t dx, int16_t dy, uint16_t *buf)
{
if (dx) for (int16_t row = 0; row < ht; row++) {
READGRAM(x, y + row, buf, wid, 1);
tft.setAddrWindow(x, y + row, x + wid - 1, y + row);
tft.pushColors(buf + dx, wid - dx, 1);
tft.pushColors(buf + 0, dx, 0);
}
if (dy) for (int16_t col = 0; col < wid; col++) {
READGRAM(x + col, y, buf, 1, ht);
tft.setAddrWindow(x + col, y, x + col, y + ht - 1);
tft.pushColors(buf + dy, ht - dy, 1);
tft.pushColors(buf + 0, dy, 0);
}
}
void printmsg(int row, const char *msg)
{
tft.setTextColor(YELLOW, BLACK);
tft.setCursor(0, row);
tft.println(msg);
}
void loop(void) {
uint8_t aspect;
uint16_t pixel;
const char *aspectname[] = {
"PORTRAIT", "LANDSCAPE", "PORTRAIT_REV", "LANDSCAPE_REV"
};
const char *colorname[] = { "BLUE", "GREEN", "RED", "GRAY" };
uint16_t colormask[] = { 0x001F, 0x07E0, 0xF800, 0xFFFF };
uint16_t dx, rgb, n, wid, ht, msglin;
tft.setRotation(0);
runtests();
delay(2000);
if (tft.height() > 64) {
for (uint8_t cnt = 0; cnt < 4; cnt++) {
aspect = (cnt + 0) & 3;
tft.setRotation(aspect);
wid = tft.width();
ht = tft.height();
msglin = (ht > 160) ? 200 : 112;
testText();
dx = wid / 32;
for (n = 0; n < 32; n++) {
rgb = n * 8;
rgb = tft.color565(rgb, rgb, rgb);
tft.fillRect(n * dx, 48, dx, 63, rgb & colormask[aspect]);
}
tft.drawRect(0, 48 + 63, wid, 1, WHITE);
tft.setTextSize(2);
tft.setTextColor(colormask[aspect], BLACK);
tft.setCursor(0, 72);
tft.print(colorname[aspect]);
tft.setTextColor(WHITE);
tft.println(" COLOR GRADES");
tft.setTextColor(WHITE, BLACK);
printmsg(184, aspectname[aspect]);
delay(1000);
tft.drawPixel(0, 0, YELLOW);
pixel = tft.readPixel(0, 0);
tft.setTextSize((ht > 160) ? 2 : 1); //for messages
#if defined(MCUFRIEND_KBV_H_)
#if 1
extern const uint8_t penguin[];
tft.setAddrWindow(wid - 40 - 40, 20 + 0, wid - 1 - 40, 20 + 39);
tft.pushColors(penguin, 1600, 1);
#elif 1
extern const uint8_t wifi_full[];
tft.setAddrWindow(wid - 40 - 40, 20 + 0, wid - 40 - 40 + 31, 20 + 31);
tft.pushColors(wifi_full, 1024, 1, true);
#elif 1
extern const uint8_t icon_40x40[];
tft.setAddrWindow(wid - 40 - 40, 20 + 0, wid - 1 - 40, 20 + 39);
tft.pushColors(icon_40x40, 1600, 1);
#endif
tft.setAddrWindow(0, 0, wid - 1, ht - 1);
if (aspect & 1) tft.drawRect(wid - 1, 0, 1, ht, WHITE);
else tft.drawRect(0, ht - 1, wid, 1, WHITE);
printmsg(msglin, "VERTICAL SCROLL UP");
uint16_t maxscroll;
if (tft.getRotation() & 1) maxscroll = wid;
else maxscroll = ht;
for (uint16_t i = 1; i <= maxscroll; i++) {
tft.vertScroll(0, maxscroll, i);
delay(10);
}
delay(1000);
printmsg(msglin, "VERTICAL SCROLL DN");
for (uint16_t i = 1; i <= maxscroll; i++) {
tft.vertScroll(0, maxscroll, 0 - (int16_t)i);
delay(10);
}
tft.vertScroll(0, maxscroll, 0);
printmsg(msglin, "SCROLL DISABLED ");
delay(1000);
if ((aspect & 1) == 0) { //Portrait
tft.setTextColor(BLUE, BLACK);
printmsg(msglin, "ONLY THE COLOR BAND");
for (uint16_t i = 1; i <= 64; i++) {
tft.vertScroll(48, 64, i);
delay(20);
}
delay(1000);
}
#endif
tft.setTextColor(YELLOW, BLACK);
if (pixel == YELLOW) {
printmsg(msglin, "SOFTWARE SCROLL ");
#if 0
// diagonal scroll of block
for (int16_t i = 45, dx = 2, dy = 1; i > 0; i -= dx) {
windowScroll(24, 8, 90, 40, dx, dy, scrollbuf);
}
#else
// plain horizontal scroll of block
n = (wid > 320) ? 320 : wid;
for (int16_t i = n, dx = 4, dy = 0; i > 0; i -= dx) {
windowScroll(0, 200, n, 16, dx, dy, scrollbuf);
}
#endif
}
else if (pixel == CYAN)
tft.println("readPixel() reads as BGR");
else if ((pixel & 0xF8F8) == 0xF8F8)
tft.println("readPixel() should be 24-bit");
else {
tft.print("readPixel() reads 0x");
tft.println(pixel, HEX);
}
delay(5000);
}
}
printmsg(msglin, "INVERT DISPLAY ");
tft.invertDisplay(true);
delay(2000);
tft.invertDisplay(false);
}
typedef struct {
PGM_P msg;
uint32_t ms;
} TEST;
TEST result[12];
#define RUNTEST(n, str, test) { result[n].msg = PSTR(str); result[n].ms = test; delay(500); }
void runtests(void)
{
uint8_t i, len = 24, cnt;
uint32_t total;
RUNTEST(0, "FillScreen ", testFillScreen());
RUNTEST(1, "Text ", testText());
RUNTEST(2, "Lines ", testLines(CYAN));
RUNTEST(3, "Horiz/Vert Lines ", testFastLines(RED, BLUE));
RUNTEST(4, "Rectangles (outline) ", testRects(GREEN));
RUNTEST(5, "Rectangles (filled) ", testFilledRects(YELLOW, MAGENTA));
RUNTEST(6, "Circles (filled) ", testFilledCircles(10, MAGENTA));
RUNTEST(7, "Circles (outline) ", testCircles(10, WHITE));
RUNTEST(8, "Triangles (outline) ", testTriangles());
RUNTEST(9, "Triangles (filled) ", testFilledTriangles());
RUNTEST(10, "Rounded rects (outline) ", testRoundRects());
RUNTEST(11, "Rounded rects (filled) ", testFilledRoundRects());
tft.fillScreen(BLACK);
tft.setTextColor(GREEN);
tft.setCursor(0, 0);
uint16_t wid = tft.width();
if (wid > 176) {
tft.setTextSize(2);
#if defined(MCUFRIEND_KBV_H_)
tft.print("MCUFRIEND ");
#if MCUFRIEND_KBV_H_ != 0
tft.print(0.01 * MCUFRIEND_KBV_H_, 2);
#else
tft.print("for");
#endif
tft.println(" UNO");
#else
tft.println("Adafruit-Style Tests");
#endif
} else len = wid / 6 - 8;
tft.setTextSize(1);
total = 0;
for (i = 0; i < 12; i++) {
PGM_P str = result[i].msg;
char c;
if (len > 24) {
if (i < 10) tft.print(" ");
tft.print(i);
tft.print(": ");
}
uint8_t cnt = len;
while ((c = pgm_read_byte(str++)) && cnt--) tft.print(c);
tft.print(" ");
tft.println(result[i].ms);
total += result[i].ms;
}
tft.setTextSize(2);
tft.print("Total:");
tft.print(0.000001 * total);
tft.println("sec");
g_identifier = tft.readID();
tft.print("ID: 0x");
tft.println(tft.readID(), HEX);
// tft.print("Reg(00):0x");
// tft.println(tft.readReg(0x00), HEX);
tft.print("F_CPU:");
tft.print(0.000001 * F_CPU);
#if defined(__OPTIMIZE_SIZE__)
tft.println("MHz -Os");
#else
tft.println("MHz");
#endif
delay(10000);
}
// Standard Adafruit tests. will adjust to screen size
unsigned long testFillScreen() {
unsigned long start = micros();
tft.fillScreen(BLACK);
tft.fillScreen(RED);
tft.fillScreen(GREEN);
tft.fillScreen(BLUE);
tft.fillScreen(BLACK);
return micros() - start;
}
unsigned long testText() {
unsigned long start;
tft.fillScreen(BLACK);
start = micros();
tft.setCursor(0, 0);
tft.setTextColor(WHITE); tft.setTextSize(1);
tft.println("Hello World!");
tft.setTextColor(YELLOW); tft.setTextSize(2);
tft.println(123.45);
tft.setTextColor(RED); tft.setTextSize(3);
tft.println(0xDEADBEEF, HEX);
tft.println();
tft.setTextColor(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(BLACK);
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
tft.fillScreen(BLACK);
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;
tft.fillScreen(BLACK);
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;
tft.fillScreen(BLACK);
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);
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(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(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(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);
}
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(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(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(0, 0, 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(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, i));
t += micros() - start;
tft.drawTriangle(cx, cy - i, cx - i, cy + i, cx + i, cy + i,
tft.color565(i, i, 0));
}
return t;
}
unsigned long testRoundRects() {
unsigned long start;
int w, i, i2, red, step,
cx = tft.width() / 2 - 1,
cy = tft.height() / 2 - 1;
tft.fillScreen(BLACK);
w = min(tft.width(), tft.height());
start = micros();
red = 0;
step = (256 * 6) / w;
for (i = 0; i < w; i += 6) {
i2 = i / 2;
red += step;
tft.drawRoundRect(cx - i2, cy - i2, i, i, i / 8, tft.color565(red, 0, 0));
}
return micros() - start;
}
unsigned long testFilledRoundRects() {
unsigned long start;
int i, i2, green, step,
cx = tft.width() / 2 - 1,
cy = tft.height() / 2 - 1;
tft.fillScreen(BLACK);
start = micros();
green = 256;
step = (256 * 6) / min(tft.width(), tft.height());
for (i = min(tft.width(), tft.height()); i > 20; i -= 6) {
i2 = i / 2;
green -= step;
tft.fillRoundRect(cx - i2, cy - i2, i, i, i / 8, tft.color565(0, green, 0));
}
return micros() - start;
}
libraries/MCUFRIEND_kbv/examples/graphictest_kbv/icons.c
+542
View File
@@ -0,0 +1,542 @@
#if defined(__arm__) || defined(ESP8266) || defined(ESP32)
#define PROGMEM
#else
#include <Arduino.h>
#endif
const unsigned char PROGMEM penguin[3200] = { /* 0X00,0X10,0X28,0X00,0X28,0X00,0X01,0X1B, */
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XBE, 0XF7, 0X7D, 0XEF,
0XBA, 0XD6, 0XB6, 0XB5, 0XF3, 0X9C, 0XB2, 0X94, 0XB3, 0X9C, 0XB2, 0X94, 0X34, 0XA5, 0XF7, 0XBD,
0XFB, 0XDE, 0X7D, 0XEF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XBE, 0XF7, 0XFB, 0XDE, 0XF3, 0X9C, 0XCB, 0X5A,
0XC7, 0X39, 0X04, 0X21, 0X82, 0X10, 0X42, 0X10, 0X42, 0X10, 0X41, 0X08, 0X83, 0X18, 0X45, 0X29,
0XC7, 0X39, 0X0C, 0X63, 0X75, 0XAD, 0X3C, 0XE7, 0XBE, 0XF7, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0X3C, 0XE7, 0XB2, 0X94, 0X08, 0X42, 0XC3, 0X18, 0X82, 0X10,
0X04, 0X21, 0X45, 0X29, 0X86, 0X31, 0X86, 0X31, 0X86, 0X31, 0X86, 0X31, 0X45, 0X29, 0X04, 0X21,
0X82, 0X10, 0X41, 0X08, 0XC3, 0X18, 0X08, 0X42, 0XF3, 0X9C, 0X3C, 0XE7, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFB, 0XDE, 0X0C, 0X63, 0XC3, 0X18, 0XC3, 0X18, 0X45, 0X29, 0XC7, 0X39,
0X08, 0X42, 0X08, 0X42, 0X08, 0X42, 0X08, 0X42, 0X08, 0X42, 0X08, 0X42, 0XC7, 0X39, 0XC7, 0X39,
0X86, 0X31, 0X86, 0X31, 0X04, 0X21, 0X41, 0X08, 0X82, 0X10, 0XCB, 0X5A, 0XBA, 0XD6, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFB, 0XDE, 0XCB, 0X5A, 0X82, 0X10, 0X45, 0X29, 0XC7, 0X39, 0X08, 0X42, 0X08, 0X42,
0X09, 0X4A, 0X49, 0X4A, 0X49, 0X4A, 0X49, 0X4A, 0X49, 0X4A, 0X49, 0X4A, 0X08, 0X42, 0XC7, 0X39,
0XC7, 0X39, 0XC7, 0X39, 0X86, 0X31, 0X45, 0X29, 0X83, 0X18, 0X00, 0X00, 0XC8, 0X41, 0X38, 0XC6,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0X7D, 0XEF, 0X8E, 0X73, 0X82, 0X10, 0X45, 0X29, 0XC7, 0X39, 0X08, 0X42, 0X09, 0X4A, 0X8A, 0X52,
0X30, 0X84, 0XCF, 0X7B, 0X8A, 0X52, 0X49, 0X4A, 0X4A, 0X52, 0X49, 0X4A, 0XCB, 0X5A, 0XCF, 0X7B,
0X0C, 0X63, 0X08, 0X42, 0XC7, 0X39, 0X86, 0X31, 0X45, 0X29, 0XC3, 0X18, 0X00, 0X00, 0X49, 0X4A,
0XBA, 0XD6, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XF3, 0X9C, 0XC3, 0X18, 0X04, 0X21, 0XC7, 0X39, 0X08, 0X42, 0X49, 0X4A, 0X49, 0X4A, 0X72, 0X94,
0X7D, 0XEF, 0X7D, 0XEF, 0XB2, 0X94, 0X4A, 0X52, 0X49, 0X4A, 0X8A, 0X52, 0X75, 0XAD, 0XBE, 0XF7,
0XBA, 0XD6, 0X4D, 0X6B, 0XC7, 0X39, 0XC7, 0X39, 0X86, 0X31, 0X45, 0X29, 0XC3, 0X18, 0X41, 0X08,
0XCF, 0X7B, 0X7C, 0XE7, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XBA, 0XD6,
0X08, 0X42, 0X82, 0X10, 0XC7, 0X39, 0X08, 0X42, 0X49, 0X4A, 0X49, 0X4A, 0X8E, 0X73, 0XFB, 0XDE,
0XFF, 0XFF, 0XBE, 0XF7, 0XBA, 0XD6, 0X8E, 0X73, 0X08, 0X42, 0X30, 0X84, 0X3C, 0XE7, 0X7D, 0XEF,
0XFF, 0XFF, 0XB6, 0XB5, 0X49, 0X4A, 0XC7, 0X39, 0X86, 0X31, 0X45, 0X29, 0X04, 0X21, 0X41, 0X08,
0X45, 0X29, 0XB6, 0XB5, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XBE, 0XF7, 0X71, 0X8C,
0X41, 0X08, 0X45, 0X29, 0X08, 0X42, 0X49, 0X4A, 0X49, 0X4A, 0X4A, 0X52, 0XB2, 0X94, 0XBE, 0XF7,
0XBE, 0XF7, 0XB2, 0X94, 0XCF, 0X7B, 0XCF, 0X7B, 0X49, 0X4A, 0XB6, 0XB5, 0XF3, 0X9C, 0X0C, 0X63,
0X38, 0XC6, 0XBA, 0XD6, 0X0C, 0X63, 0X87, 0X39, 0XC7, 0X39, 0X86, 0X31, 0X45, 0X29, 0XC3, 0X18,
0X41, 0X08, 0X30, 0X84, 0X7D, 0XEF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0X3C, 0XE7, 0XCB, 0X5A,
0X41, 0X08, 0XC7, 0X39, 0X08, 0X42, 0X49, 0X4A, 0X4A, 0X52, 0X8A, 0X52, 0XF3, 0X9C, 0XFF, 0XFF,
0X7D, 0XEF, 0XC7, 0X39, 0XC3, 0X18, 0X0C, 0X63, 0XCB, 0X5A, 0XB6, 0XB5, 0XB2, 0X94, 0XCB, 0X5A,
0X75, 0XAD, 0XFA, 0XD6, 0X4D, 0X6B, 0X87, 0X39, 0XC7, 0X39, 0X86, 0X31, 0X45, 0X29, 0X04, 0X21,
0X41, 0X08, 0X8A, 0X52, 0X79, 0XCE, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0X38, 0XC6, 0X86, 0X31,
0X04, 0X21, 0XC8, 0X41, 0X49, 0X4A, 0X49, 0X4A, 0X4A, 0X52, 0X49, 0X4A, 0XB1, 0X8C, 0XBE, 0XF7,
0XBE, 0XF7, 0XB2, 0X94, 0XCF, 0X7B, 0XCF, 0X7B, 0X49, 0X4A, 0X74, 0XA5, 0X7D, 0XEF, 0X7C, 0XE7,
0XBE, 0XF7, 0X79, 0XCE, 0X0C, 0X63, 0XC7, 0X39, 0XC7, 0X39, 0X86, 0X31, 0X45, 0X29, 0X04, 0X21,
0X82, 0X10, 0X45, 0X29, 0X75, 0XAD, 0XBE, 0XF7, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0X34, 0XA5, 0X82, 0X10,
0X86, 0X31, 0X08, 0X42, 0X49, 0X4A, 0X49, 0X4A, 0X8A, 0X52, 0X49, 0X4A, 0X4D, 0X6B, 0XBA, 0XD6,
0XFF, 0XFF, 0XFF, 0XFF, 0X79, 0XCE, 0X0D, 0X63, 0XC7, 0X39, 0XCF, 0X7B, 0X7D, 0XEF, 0XFF, 0XFF,
0XFF, 0XFF, 0X75, 0XAD, 0X08, 0X42, 0X86, 0X31, 0XC7, 0X39, 0X86, 0X31, 0X45, 0X29, 0X45, 0X29,
0XC3, 0X18, 0XC3, 0X18, 0XB2, 0X94, 0X7D, 0XEF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XBE, 0XF7, 0XB2, 0X8C, 0X41, 0X08,
0XC7, 0X39, 0X08, 0X42, 0X49, 0X4A, 0X49, 0X4A, 0X8A, 0X52, 0X8A, 0X52, 0X4A, 0X4A, 0XD0, 0X7B,
0X7A, 0XC6, 0X7B, 0XBE, 0X90, 0X6B, 0XC9, 0X39, 0X88, 0X31, 0XC9, 0X39, 0XB3, 0X84, 0XBB, 0XC6,
0XF8, 0XB5, 0XCC, 0X5A, 0X86, 0X31, 0XC7, 0X39, 0XC7, 0X39, 0X86, 0X31, 0X45, 0X29, 0X45, 0X29,
0XC4, 0X20, 0X41, 0X08, 0X30, 0X84, 0X3C, 0XE7, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0X3C, 0XE7, 0X8A, 0X4A, 0XC3, 0X10,
0XC7, 0X39, 0X08, 0X42, 0X49, 0X4A, 0X49, 0X4A, 0X4A, 0X4A, 0X4A, 0X42, 0X09, 0X3A, 0X08, 0X4A,
0X09, 0X6B, 0X49, 0X7B, 0XC6, 0X7A, 0X05, 0X83, 0X46, 0X83, 0XC5, 0X7A, 0XC6, 0X72, 0X09, 0X7B,
0X48, 0X5A, 0X87, 0X31, 0X88, 0X21, 0X88, 0X29, 0X86, 0X31, 0X86, 0X31, 0X45, 0X29, 0X45, 0X29,
0X04, 0X21, 0X41, 0X08, 0X4A, 0X4A, 0XBA, 0XD6, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XF7, 0XC5, 0X82, 0X50, 0X05, 0X41,
0XC7, 0X29, 0X08, 0X42, 0X49, 0X4A, 0X4A, 0X42, 0X49, 0X4A, 0X09, 0X7B, 0X88, 0X9B, 0XC6, 0XB3,
0X21, 0XD4, 0XA0, 0XDC, 0XE1, 0XE4, 0X61, 0XED, 0X61, 0XED, 0X21, 0XED, 0XA0, 0XE4, 0X20, 0XDC,
0X80, 0XCB, 0X43, 0XAB, 0XC4, 0X82, 0X06, 0X5A, 0X47, 0X21, 0X46, 0X29, 0X45, 0X29, 0X04, 0X29,
0X04, 0X19, 0X82, 0X10, 0X82, 0X18, 0XF3, 0X9C, 0X7D, 0XEF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0X7D, 0XEF, 0X4D, 0X93, 0X00, 0XA0, 0X82, 0XB8,
0XC7, 0X31, 0X09, 0X32, 0X49, 0X4A, 0X86, 0X7A, 0X43, 0XC3, 0X6B, 0XED, 0XF4, 0XF6, 0XEB, 0XFD,
0X20, 0XFD, 0X20, 0XFD, 0X60, 0XFD, 0XA0, 0XFD, 0XA0, 0XFD, 0X60, 0XFD, 0X60, 0XFD, 0X20, 0XFD,
0XE0, 0XFC, 0XA0, 0XFC, 0X60, 0XF4, 0XC1, 0XDB, 0X83, 0X9A, 0XC5, 0X49, 0X45, 0X29, 0X04, 0X19,
0XC4, 0X20, 0X82, 0X38, 0X00, 0X50, 0XCB, 0X6A, 0XBA, 0XD6, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFB, 0XEE, 0X04, 0XA1, 0X00, 0XC0, 0X00, 0XF0,
0XC3, 0XA0, 0XC8, 0X41, 0X49, 0X42, 0X05, 0X9B, 0X20, 0XFC, 0XA4, 0XFC, 0X69, 0XFD, 0XE8, 0XFD,
0X63, 0XFD, 0X20, 0XFD, 0X60, 0XFD, 0X60, 0XFD, 0X60, 0XFD, 0X20, 0XFD, 0X20, 0XFD, 0XE0, 0XFC,
0XE0, 0XFC, 0XA0, 0XFC, 0X60, 0XFC, 0X20, 0XFC, 0X41, 0XD3, 0XC5, 0X49, 0X45, 0X19, 0XC4, 0X38,
0X82, 0X68, 0X41, 0X88, 0X00, 0X70, 0X49, 0X5A, 0X79, 0XCE, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFB, 0XF6, 0X82, 0XC0, 0X00, 0XD0, 0X86, 0XC1,
0X46, 0XF1, 0X41, 0XC8, 0X45, 0X79, 0X89, 0X52, 0X88, 0X62, 0X86, 0X6A, 0XC6, 0X7A, 0XC4, 0XBB,
0XE1, 0XFC, 0X60, 0XFD, 0X60, 0XFD, 0XA0, 0XFD, 0XA0, 0XFD, 0X60, 0XFD, 0X60, 0XFD, 0XE0, 0XFC,
0X60, 0XE4, 0X03, 0X93, 0X84, 0X72, 0X44, 0X6A, 0XC5, 0X41, 0X45, 0X29, 0XC3, 0X58, 0X41, 0XA8,
0X40, 0X98, 0X00, 0XB0, 0X00, 0X60, 0X0C, 0X6B, 0X79, 0XCE, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0X7D, 0XEF, 0XCE, 0X83, 0X82, 0X88, 0X00, 0XF8, 0XC4, 0XD8,
0X0C, 0XF3, 0X8A, 0XFA, 0X82, 0XE8, 0X82, 0XB0, 0X45, 0X69, 0XC7, 0X51, 0X08, 0X42, 0X08, 0X3A,
0X86, 0X5A, 0X83, 0X9B, 0XA2, 0XBC, 0X22, 0XCD, 0X21, 0XCD, 0XA1, 0XC4, 0X22, 0XB4, 0XC4, 0X7A,
0X06, 0X3A, 0X86, 0X29, 0X45, 0X29, 0X05, 0X31, 0XC4, 0X50, 0X41, 0X90, 0X00, 0XC0, 0X00, 0XA8,
0X00, 0XA0, 0X00, 0XA8, 0X00, 0X30, 0X4A, 0X4A, 0XBA, 0XD6, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0X7D, 0XEF, 0X8E, 0X73, 0XC3, 0X18, 0X05, 0X39, 0X82, 0XA8, 0X00, 0XF8,
0XC3, 0XF8, 0X4D, 0XFB, 0X4D, 0XFB, 0XC7, 0XF9, 0XC3, 0XF0, 0X82, 0XD8, 0XC3, 0XB0, 0X04, 0X81,
0X45, 0X61, 0X46, 0X51, 0X86, 0X49, 0X86, 0X49, 0X46, 0X41, 0X45, 0X41, 0X45, 0X41, 0X45, 0X41,
0X05, 0X49, 0X04, 0X61, 0X82, 0X90, 0X41, 0XB0, 0X00, 0XD0, 0X00, 0XC8, 0X00, 0XA8, 0X00, 0XA8,
0X00, 0XB8, 0X41, 0X58, 0X82, 0X10, 0X82, 0X10, 0XB2, 0X94, 0XBE, 0XF7, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XBE, 0XF7, 0XCF, 0X7B, 0X82, 0X10, 0X04, 0X21, 0X86, 0X29, 0X86, 0X41, 0X04, 0X99,
0X40, 0XE8, 0X41, 0XF8, 0X86, 0XF9, 0XCB, 0XFA, 0X49, 0XFA, 0X82, 0XF8, 0X00, 0XF8, 0X00, 0XF0,
0X00, 0XE8, 0X41, 0XD8, 0X41, 0XD0, 0X41, 0XC0, 0X41, 0XC0, 0X41, 0XC0, 0X41, 0XC0, 0X41, 0XC8,
0X00, 0XD0, 0X00, 0XE0, 0X00, 0XE0, 0X00, 0XD8, 0X00, 0XD0, 0X00, 0XB8, 0X00, 0XA8, 0X41, 0X88,
0X82, 0X48, 0X82, 0X10, 0X82, 0X10, 0X00, 0X00, 0X45, 0X29, 0X79, 0XCE, 0XFF, 0XFF, 0XFF, 0XFF,
0XBE, 0XF7, 0XF3, 0X9C, 0X82, 0X10, 0XC3, 0X18, 0X45, 0X29, 0X86, 0X31, 0XC7, 0X31, 0X30, 0X7C,
0XF3, 0XDC, 0X86, 0XE1, 0X00, 0XF0, 0X00, 0XF8, 0X41, 0XF8, 0X41, 0XF8, 0X00, 0XF8, 0X00, 0XF8,
0X00, 0XF8, 0X00, 0XF8, 0X00, 0XF8, 0X00, 0XF8, 0X00, 0XF8, 0X00, 0XF8, 0X00, 0XF8, 0X00, 0XF8,
0X00, 0XE8, 0X00, 0XE0, 0X00, 0XE0, 0X00, 0XD8, 0X00, 0XC8, 0X41, 0XA0, 0X8A, 0X9A, 0X0C, 0X63,
0X04, 0X11, 0X82, 0X10, 0X82, 0X10, 0X41, 0X08, 0X00, 0X00, 0X4D, 0X6B, 0X7D, 0XEF, 0XFF, 0XFF,
0XFB, 0XDE, 0X08, 0X42, 0X42, 0X10, 0X45, 0X29, 0X86, 0X31, 0X86, 0X31, 0X49, 0X4A, 0X38, 0XBE,
0XFF, 0XFF, 0X38, 0XD6, 0X86, 0XA9, 0X00, 0XC8, 0X00, 0XE0, 0X00, 0XF0, 0X00, 0XF8, 0X00, 0XF8,
0X00, 0XF8, 0X00, 0XF8, 0X00, 0XF8, 0X00, 0XF8, 0X00, 0XF8, 0X00, 0XF8, 0X00, 0XF0, 0X00, 0XF0,
0X00, 0XE8, 0X00, 0XE0, 0X00, 0XD0, 0XC3, 0X98, 0X8A, 0X8A, 0XB2, 0XA4, 0XBA, 0XC6, 0XF7, 0XB5,
0X08, 0X42, 0X41, 0X08, 0X82, 0X10, 0X41, 0X08, 0X00, 0X00, 0X45, 0X29, 0XF7, 0XBD, 0XFF, 0XFF,
0X71, 0X8C, 0X41, 0X08, 0X04, 0X21, 0X45, 0X29, 0X86, 0X31, 0X86, 0X31, 0X0C, 0X63, 0X3C, 0XE7,
0XFF, 0XFF, 0X79, 0XD6, 0X46, 0XB9, 0X00, 0XE0, 0X42, 0XC8, 0X82, 0XA8, 0X82, 0XB0, 0X41, 0XD8,
0X82, 0XE8, 0X82, 0XF0, 0X41, 0XE8, 0X41, 0XE8, 0X41, 0XE8, 0X41, 0XF0, 0X41, 0XE8, 0X41, 0XD8,
0X04, 0XC1, 0X08, 0X92, 0X4D, 0X8B, 0X34, 0XA5, 0XFB, 0XC6, 0XFB, 0XD6, 0XBA, 0XCE, 0X3C, 0XE7,
0X30, 0X84, 0XC3, 0X18, 0X41, 0X08, 0X41, 0X08, 0X00, 0X00, 0X41, 0X08, 0XCF, 0X7B, 0X7D, 0XEF,
0X49, 0X4A, 0X00, 0X00, 0X04, 0X21, 0X45, 0X29, 0X46, 0X31, 0X86, 0X31, 0X30, 0X84, 0XFF, 0XFF,
0XFF, 0XF7, 0XF7, 0XDD, 0X09, 0XDA, 0X83, 0XF8, 0X01, 0XF0, 0X42, 0XC0, 0X82, 0X98, 0X49, 0X9A,
0XF3, 0XB4, 0XF3, 0XCC, 0X71, 0XBC, 0X8E, 0XBB, 0X8E, 0XBB, 0X30, 0XBC, 0X71, 0XBC, 0XF3, 0XBC,
0XB6, 0XBD, 0XFB, 0XCE, 0XBE, 0XE7, 0X7D, 0XE7, 0X3B, 0XDF, 0XBA, 0XD6, 0X79, 0XCE, 0XFB, 0XDE,
0X75, 0XAD, 0X86, 0X31, 0X41, 0X08, 0X41, 0X08, 0X00, 0X00, 0X00, 0X00, 0X49, 0X4A, 0XFB, 0XDE,
0X04, 0X21, 0X41, 0X08, 0X04, 0X21, 0X45, 0X29, 0X45, 0X29, 0X87, 0X39, 0XB2, 0X94, 0XFF, 0XFF,
0XBE, 0XF7, 0X34, 0XDD, 0X0C, 0XEB, 0X09, 0XFA, 0X00, 0XF0, 0X01, 0XD8, 0X00, 0XD8, 0X8B, 0XD2,
0X7D, 0XE7, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XBE, 0XFF, 0X7D, 0XEF, 0XFB, 0XDE, 0XFB, 0XDE, 0XBA, 0XD6, 0X79, 0XCE, 0XBA, 0XD6,
0X78, 0XC6, 0XC7, 0X39, 0X00, 0X00, 0X41, 0X08, 0X00, 0X00, 0X00, 0X00, 0XC7, 0X39, 0X79, 0XCE,
0X00, 0X00, 0X82, 0X10, 0XC3, 0X18, 0X04, 0X21, 0X05, 0X29, 0X86, 0X31, 0XB3, 0X9C, 0XFF, 0XFF,
0XFF, 0XF7, 0X75, 0XDD, 0XC7, 0XE9, 0XC7, 0XF9, 0X01, 0XF8, 0X01, 0XF0, 0X00, 0XE8, 0X49, 0XE2,
0XFB, 0XEE, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XBE, 0XF7, 0X7D, 0XEF, 0XFB, 0XDE, 0XFB, 0XDE, 0XBA, 0XD6, 0X79, 0XCE, 0XBA, 0XD6,
0XB9, 0XCE, 0X08, 0X42, 0X00, 0X00, 0X00, 0X00, 0X00, 0X00, 0X00, 0X00, 0XC7, 0X39, 0X38, 0XC6,
0X00, 0X00, 0X82, 0X10, 0X82, 0X10, 0X04, 0X21, 0X04, 0X21, 0X45, 0X29, 0X30, 0X84, 0XFF, 0XFF,
0XFF, 0XFF, 0X38, 0XDE, 0XC4, 0XD0, 0X00, 0XF0, 0X01, 0XF8, 0X00, 0XF8, 0X00, 0XF0, 0X08, 0XD2,
0XFB, 0XE6, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XBE, 0XF7, 0X7D, 0XEF, 0XFB, 0XDE, 0XBA, 0XD6, 0X79, 0XCE, 0X79, 0XCE, 0XBA, 0XD6,
0X79, 0XCE, 0XC7, 0X39, 0X41, 0X08, 0X00, 0X00, 0X00, 0X00, 0X00, 0X00, 0X86, 0X31, 0X38, 0XC6,
0X00, 0X00, 0X00, 0X00, 0XC3, 0X18, 0XCB, 0X5A, 0X86, 0X31, 0XC3, 0X18, 0XCB, 0X5A, 0X7D, 0XEF,
0XFF, 0XFF, 0X7D, 0XEF, 0XCF, 0XBB, 0XC3, 0XB0, 0X41, 0XD0, 0X41, 0XD0, 0X82, 0XB8, 0X4D, 0XB3,
0X7D, 0XE7, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XBE, 0XF7, 0XBE, 0XF7, 0X3D, 0XEF, 0XFB, 0XDE, 0XBA, 0XD6, 0X79, 0XCE, 0X79, 0XCE, 0XFA, 0XD6,
0XF7, 0XBD, 0X04, 0X21, 0X86, 0X31, 0X04, 0X21, 0X00, 0X00, 0X00, 0X00, 0X86, 0X31, 0X38, 0XC6,
0X86, 0X31, 0XC3, 0X18, 0XCB, 0X5A, 0X75, 0XAD, 0XCF, 0X7B, 0X41, 0X08, 0X86, 0X31, 0XF7, 0XBD,
0XFF, 0XFF, 0XFF, 0XFF, 0XBE, 0XEF, 0X74, 0XB5, 0X30, 0X9C, 0X30, 0X9C, 0X72, 0XA4, 0XBB, 0XD6,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XBE, 0XF7, 0X7D, 0XEF, 0X3C, 0XE7, 0XFB, 0XDE, 0XBA, 0XD6, 0X79, 0XCE, 0X79, 0XCE, 0X3C, 0XE7,
0X71, 0X8C, 0X81, 0X08, 0X0C, 0X63, 0XCF, 0X7B, 0X82, 0X10, 0X00, 0X00, 0X8A, 0X52, 0X38, 0XC6,
0X75, 0XAD, 0X71, 0X8C, 0XB6, 0XB5, 0X3C, 0XE7, 0XFB, 0XDE, 0XC7, 0X39, 0X00, 0X00, 0XCF, 0X73,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XBE, 0XF7,
0X7D, 0XEF, 0X7D, 0XEF, 0X3B, 0XDF, 0XFA, 0XD6, 0X79, 0XCE, 0X79, 0XCE, 0XFB, 0XDE, 0XB9, 0XCE,
0XC7, 0X39, 0XC4, 0X20, 0X71, 0X8C, 0XBA, 0XD6, 0X71, 0X8C, 0XCB, 0X5A, 0XB2, 0X94, 0XBA, 0XD6,
0XFF, 0XFF, 0X7D, 0XEF, 0X7D, 0XEF, 0XFF, 0XFF, 0XFF, 0XFF, 0XB6, 0XB5, 0X46, 0X29, 0X05, 0X19,
0X75, 0XA5, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XBE, 0XF7,
0X7D, 0XEF, 0X3C, 0XE7, 0XFB, 0XDE, 0XBA, 0XD6, 0X79, 0XCE, 0XBA, 0XD6, 0XFC, 0XDE, 0X4E, 0X63,
0X42, 0X08, 0X0C, 0X63, 0XF7, 0XBD, 0XBE, 0XF7, 0XFF, 0XFF, 0XFB, 0XDE, 0XFB, 0XDE, 0XBE, 0XF7,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XF4, 0X9C, 0X04, 0X21,
0X05, 0X21, 0XB6, 0XA5, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XBE, 0XF7, 0XBE, 0XF7, 0X7D, 0XEF,
0X3C, 0XE7, 0XFB, 0XDE, 0XBA, 0XD6, 0X79, 0XCE, 0XFB, 0XDE, 0XBB, 0XD6, 0XD1, 0X73, 0X83, 0X18,
0X86, 0X39, 0X34, 0X9D, 0XBD, 0XEF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XBE, 0XFF, 0X35, 0XD6, 0XEB, 0XCC, 0X43, 0XB3,
0X40, 0X51, 0X05, 0X19, 0XF5, 0X8C, 0XBE, 0XEF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XBE, 0XF7, 0XBE, 0XF7, 0X7D, 0XEF, 0X7D, 0XEF, 0X3C, 0XE7,
0XFB, 0XDE, 0XBA, 0XDE, 0XBA, 0XD6, 0X3C, 0XDF, 0X3A, 0XBE, 0X4F, 0X63, 0X82, 0X49, 0X40, 0XA3,
0X23, 0XB4, 0XCC, 0X83, 0X3A, 0XBE, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XBF, 0XF7, 0XB5, 0XBD, 0X82, 0X92, 0X20, 0XF4, 0XA0, 0XFC,
0X60, 0XE4, 0X40, 0X82, 0X84, 0X41, 0X8F, 0X6B, 0X77, 0XAD, 0X3D, 0XE7, 0XFF, 0XFF, 0XFF, 0XFF,
0XFE, 0XFF, 0XBE, 0XF7, 0XBE, 0XF7, 0XBE, 0XF7, 0X7D, 0XEF, 0X7D, 0XEF, 0X3C, 0XE7, 0XFB, 0XDE,
0XFB, 0XDE, 0X3D, 0XE7, 0XBB, 0XCE, 0X36, 0X9D, 0X0B, 0X6B, 0X41, 0X6A, 0X60, 0XC4, 0X20, 0XFE,
0X60, 0XF5, 0X00, 0X8B, 0XC7, 0X6A, 0X38, 0XC6, 0XBE, 0XF7, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0X7D, 0XEF, 0X4B, 0X7B, 0X80, 0XB2, 0XA0, 0XFC, 0XA0, 0XFC,
0XE0, 0XFC, 0XE0, 0XFC, 0XC0, 0XCB, 0XC1, 0X8A, 0X45, 0X62, 0X4D, 0X6B, 0XB3, 0X94, 0XF7, 0XBD,
0X3D, 0XDF, 0XFF, 0XF7, 0XFF, 0XFF, 0XBE, 0XF7, 0X7D, 0XEF, 0X7D, 0XEF, 0X7D, 0XE7, 0X3D, 0XDF,
0XBA, 0XC6, 0X75, 0XA5, 0X8D, 0X7B, 0X84, 0X7A, 0X40, 0XB3, 0XE0, 0XEC, 0XE0, 0XFD, 0XE0, 0XFD,
0X60, 0XF5, 0X20, 0XE5, 0XA0, 0XD4, 0X0A, 0X6B, 0XFB, 0XDE, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0X7D, 0XEF, 0XCC, 0X93, 0X40, 0XEB, 0X60, 0XFC, 0XA0, 0XFC,
0XE0, 0XFC, 0X20, 0XFD, 0X60, 0XFD, 0X20, 0XF5, 0XA0, 0XD4, 0XC0, 0XBB, 0X42, 0X9B, 0X45, 0X8B,
0X6B, 0X9C, 0XAE, 0X9C, 0X71, 0X8C, 0XB3, 0X94, 0X33, 0X9D, 0X34, 0XA5, 0XF2, 0XA4, 0XF0, 0XB4,
0XCA, 0X9B, 0X04, 0X9B, 0X40, 0XBB, 0X20, 0XE4, 0X20, 0XFD, 0XA0, 0XFD, 0XA0, 0XFD, 0XE0, 0XFD,
0XE0, 0XFD, 0XE0, 0XFD, 0X20, 0XC4, 0X88, 0X5A, 0X38, 0XBE, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0X78, 0XD6, 0X46, 0XAB, 0X40, 0XDB, 0X20, 0XF4,
0X60, 0XFC, 0XA0, 0XFC, 0XE0, 0XFC, 0X60, 0XFD, 0XA0, 0XFD, 0X60, 0XFD, 0X20, 0XF5, 0XA0, 0XDC,
0XC0, 0XB3, 0XC0, 0X51, 0X86, 0X29, 0X0D, 0X63, 0X8F, 0X7B, 0X0D, 0X5B, 0XC7, 0X41, 0X01, 0X82,
0X00, 0XC3, 0XC0, 0XE3, 0X60, 0XFC, 0XA0, 0XFC, 0XE0, 0XFC, 0XE0, 0XFC, 0X60, 0XF5, 0X60, 0XF5,
0X20, 0XE5, 0X80, 0X9B, 0X86, 0X62, 0X30, 0X84, 0X79, 0XCE, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0X38, 0XC6, 0X2D, 0X9C, 0X05, 0X93,
0X43, 0XA3, 0X82, 0XB3, 0XC2, 0XBB, 0XC2, 0XBB, 0X22, 0XB4, 0X82, 0XA3, 0X42, 0X93, 0XC3, 0X7A,
0X85, 0X62, 0X0B, 0X63, 0X71, 0X84, 0XB6, 0XB5, 0X79, 0XCE, 0X79, 0XC6, 0XB5, 0XAD, 0X70, 0X94,
0X4A, 0X8B, 0X06, 0X83, 0X04, 0X93, 0X04, 0X9B, 0X43, 0X9B, 0X43, 0X9B, 0X43, 0X93, 0X04, 0X83,
0X08, 0X73, 0X8D, 0X73, 0XB3, 0X94, 0X79, 0XCE, 0X7D, 0XEF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0X3C, 0XDF, 0X38, 0XBE,
0X75, 0XB5, 0X33, 0XA5, 0X33, 0XA5, 0XF3, 0X9C, 0XF3, 0X9C, 0XF3, 0X9C, 0XF3, 0X94, 0XF3, 0X9C,
0X35, 0XA5, 0XF8, 0XBD, 0XFB, 0XDE, 0XBE, 0XF7, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0X7E, 0XEF,
0XBB, 0XD6, 0XF8, 0XBD, 0XB6, 0XAD, 0X75, 0XAD, 0X34, 0XA5, 0X33, 0X9D, 0X34, 0X9D, 0X35, 0XA5,
0XB7, 0XAD, 0X79, 0XC6, 0X3C, 0XE7, 0XBE, 0XF7, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
};
const unsigned char PROGMEM icon_40x40[3200] = { /* 0X00,0X10,0X28,0X00,0X28,0X00,0X01,0X1B, */
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0X5D, 0XEF, 0X71, 0X8C, 0X31, 0X84, 0X31, 0X84,
0X93, 0XC5, 0X92, 0XCD, 0X91, 0XCD, 0X91, 0XD5, 0X91, 0XD5, 0X91, 0XCD, 0X72, 0XCD, 0X72, 0XC5,
0X56, 0XDE, 0XBE, 0XFF, 0XDB, 0XDE, 0XFB, 0XDE, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XCE, 0X7B, 0X00, 0X00, 0X00, 0X00, 0X00, 0X00,
0X00, 0X5A, 0X20, 0XDD, 0X20, 0XDD, 0X20, 0XDD, 0X20, 0XDD, 0X20, 0XDD, 0XE0, 0XD4, 0XA0, 0XD4,
0X61, 0XA3, 0XA7, 0X39, 0XE5, 0X18, 0X05, 0X21, 0X92, 0X94, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XF9, 0XEE, 0XEB, 0X9B, 0XA1, 0X18, 0X23, 0X73, 0X81, 0XC5, 0X21, 0X9C,
0X61, 0X39, 0X81, 0XEE, 0X40, 0XFF, 0XE0, 0XFE, 0XE0, 0XFE, 0XE0, 0XFE, 0X40, 0XFF, 0XC0, 0XF6,
0XC0, 0X49, 0XA0, 0X18, 0X00, 0X42, 0X60, 0X18, 0X00, 0X00, 0X74, 0XB5, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0X93, 0XCD, 0XC3, 0XBB, 0XA0, 0X51, 0XE1, 0X39, 0XC2, 0XFF, 0XE0, 0XFF, 0XE0, 0XFF,
0X63, 0XBD, 0X61, 0XE6, 0X40, 0XFF, 0XE0, 0XFE, 0XE0, 0XFE, 0XC0, 0XFE, 0X60, 0XFF, 0X21, 0X73,
0XE1, 0X28, 0X81, 0XEE, 0X61, 0XFF, 0X21, 0XEE, 0XA0, 0X41, 0X20, 0X08, 0X90, 0XCD, 0XDE, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0X5C, 0XF7,
0X0B, 0XAC, 0XC0, 0XB3, 0XA1, 0XEE, 0XC3, 0X5A, 0X22, 0X8C, 0XE1, 0XFF, 0X40, 0XFF, 0X40, 0XFF,
0XC0, 0XFF, 0X80, 0XFF, 0X20, 0XFF, 0X20, 0XFF, 0X20, 0XFF, 0X00, 0XFF, 0X20, 0XFF, 0XA1, 0XAC,
0X21, 0XC5, 0X20, 0XFF, 0X60, 0XFE, 0X00, 0XFF, 0X02, 0XDE, 0XE0, 0X20, 0X40, 0X82, 0X49, 0XBC,
0X3B, 0XEF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0X5C, 0XF7, 0X67, 0X9B,
0XE0, 0XB3, 0X81, 0XFF, 0XC3, 0XFF, 0X83, 0X9C, 0X82, 0XDE, 0XC0, 0XFF, 0X60, 0XFF, 0X60, 0XFF,
0X40, 0XFF, 0X60, 0XFF, 0X40, 0XFF, 0X40, 0XFF, 0X40, 0XFF, 0X20, 0XFF, 0X00, 0XFF, 0X60, 0XFF,
0X40, 0XFF, 0XA0, 0XFE, 0X80, 0XFE, 0X40, 0XFE, 0XE0, 0XFE, 0XA2, 0XB4, 0X41, 0XBC, 0X20, 0XCC,
0X87, 0XA3, 0XB8, 0XE6, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0X9D, 0XF7, 0XA8, 0XA3, 0X60, 0XBC,
0XA2, 0XFF, 0XA5, 0XFF, 0X44, 0XFF, 0XA1, 0XFF, 0XA0, 0XFF, 0X60, 0XFF, 0X80, 0XFF, 0X80, 0XFF,
0X80, 0XFF, 0X80, 0XFF, 0X60, 0XFF, 0X60, 0XFF, 0X40, 0XFF, 0X40, 0XFF, 0X20, 0XFF, 0X20, 0XFF,
0X00, 0XFF, 0XC0, 0XFE, 0XA0, 0XFE, 0X80, 0XFE, 0X40, 0XFE, 0X60, 0XFE, 0X20, 0XFE, 0X40, 0XFE,
0XE0, 0XCB, 0XE3, 0X92, 0X7C, 0XF7, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0X4C, 0XAC, 0XC0, 0XB3, 0XA4, 0XFF,
0XA6, 0XFF, 0X45, 0XFF, 0X62, 0XFF, 0X80, 0XFF, 0X80, 0XFF, 0X80, 0XFF, 0XA0, 0XFF, 0XA0, 0XFF,
0XA0, 0XFF, 0XA0, 0XFF, 0X80, 0XFF, 0X80, 0XFF, 0X80, 0XFF, 0X60, 0XFF, 0X40, 0XFF, 0X40, 0XFF,
0X20, 0XFF, 0XE0, 0XFE, 0XC0, 0XFE, 0X80, 0XFE, 0X60, 0XFE, 0X40, 0XFE, 0X20, 0XFE, 0X00, 0XFE,
0XE0, 0XFD, 0XE0, 0XC3, 0X2A, 0XAC, 0X7D, 0XF7, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XD4, 0XD5, 0X40, 0XAB, 0X43, 0XFF, 0XA8, 0XFF,
0X67, 0XFF, 0X62, 0XFF, 0X80, 0XFF, 0X80, 0XFF, 0XA0, 0XFF, 0XA0, 0XFF, 0XC0, 0XFF, 0XC0, 0XFF,
0XC0, 0XFF, 0XA0, 0XFF, 0XA0, 0XFF, 0XA0, 0XFF, 0X80, 0XFF, 0X80, 0XFF, 0X60, 0XFF, 0X40, 0XFF,
0X40, 0XFF, 0X00, 0XFF, 0XE0, 0XFE, 0XA0, 0XFE, 0X80, 0XFE, 0X40, 0XFE, 0X20, 0XFE, 0XE0, 0XFD,
0XE0, 0XFD, 0XC0, 0XFD, 0XA0, 0XA2, 0X11, 0XBD, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XDA, 0XE6, 0XE4, 0X9A, 0XE1, 0XE5, 0XE8, 0XFF, 0X69, 0XFF,
0X65, 0XFF, 0X60, 0XFF, 0X80, 0XFF, 0XA0, 0XFF, 0XC0, 0XFF, 0XE0, 0XFF, 0XE0, 0XFF, 0XE0, 0XFF,
0XE0, 0XFF, 0XC0, 0XFF, 0XC0, 0XFF, 0XA0, 0XFF, 0XA0, 0XFF, 0X80, 0XFF, 0X80, 0XFF, 0X60, 0XFF,
0X40, 0XFF, 0X00, 0XFF, 0X00, 0XFF, 0X20, 0XFF, 0XE0, 0XFE, 0X60, 0XFE, 0X20, 0XFE, 0X00, 0XFE,
0XC0, 0XFD, 0XE0, 0XFD, 0XE0, 0XE4, 0X85, 0XAB, 0XFA, 0XE6, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0X2B, 0XB4, 0XC0, 0XB3, 0XC8, 0XFF, 0X8C, 0XFF, 0X68, 0XFF,
0X61, 0XFF, 0XA0, 0XFF, 0XA0, 0XFF, 0XC0, 0XFF, 0XE0, 0XFF, 0XE1, 0XFF, 0XA1, 0XDE, 0X61, 0XEF,
0XE1, 0XFF, 0XE0, 0XFF, 0XE0, 0XFF, 0XC0, 0XFF, 0XC0, 0XFF, 0XA0, 0XFF, 0X80, 0XFF, 0X60, 0XFF,
0X40, 0XFF, 0X60, 0XFF, 0XC0, 0XFF, 0X61, 0XDE, 0X00, 0XE6, 0X80, 0XFE, 0X40, 0XFE, 0X00, 0XFE,
0XE0, 0XFD, 0XC0, 0XFD, 0XE0, 0XFD, 0XC0, 0XC3, 0XE9, 0XAB, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0X5D, 0XEF, 0XA3, 0XAB, 0XA3, 0XF6, 0XCC, 0XFF, 0X4C, 0XFF, 0X64, 0XFF,
0X80, 0XFF, 0XA0, 0XFF, 0XC0, 0XFF, 0XE0, 0XFF, 0X61, 0XEF, 0X22, 0X6B, 0X82, 0X5A, 0X82, 0XB5,
0XE2, 0XFF, 0XE1, 0XFF, 0XE0, 0XFF, 0XE0, 0XFF, 0XE0, 0XFF, 0XA0, 0XFF, 0X80, 0XFF, 0X60, 0XFF,
0XA0, 0XFF, 0XE1, 0XFF, 0X42, 0X8C, 0XC1, 0X41, 0X21, 0XA4, 0XA0, 0XFE, 0X80, 0XFE, 0X20, 0XFE,
0XE0, 0XFD, 0XC0, 0XFD, 0XA0, 0XFD, 0X20, 0XF5, 0XC0, 0X9A, 0X35, 0XD6, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0X51, 0XC5, 0X60, 0XBC, 0XC9, 0XFF, 0X8E, 0XFF, 0X6A, 0XFF, 0X61, 0XFF,
0X80, 0XFF, 0XA0, 0XFF, 0XC0, 0XFF, 0XE1, 0XFF, 0XE1, 0X62, 0X80, 0X10, 0X05, 0XE7, 0XA4, 0XF7,
0XE4, 0XFF, 0XE3, 0XFF, 0XE2, 0XFF, 0XE0, 0XFF, 0XE0, 0XFF, 0XC0, 0XFF, 0XA0, 0XFF, 0XA0, 0XFF,
0XC1, 0XFF, 0XE2, 0X83, 0X40, 0X08, 0X22, 0XCE, 0X60, 0XF7, 0XA0, 0XFE, 0X60, 0XFE, 0X20, 0XFE,
0XE0, 0XFD, 0XC0, 0XFD, 0X80, 0XFD, 0XA0, 0XFD, 0XA0, 0XC3, 0XAC, 0XBC, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XDE, 0XFF, 0XA7, 0XAB, 0X81, 0XDD, 0XED, 0XFF, 0XB0, 0XFF, 0X69, 0XFF, 0X60, 0XFF,
0X80, 0XFF, 0XA0, 0XFF, 0XE0, 0XFF, 0X61, 0XD6, 0X22, 0X29, 0XA6, 0X31, 0XE3, 0X7B, 0X46, 0XEF,
0XE6, 0XFF, 0XE4, 0XFF, 0XE2, 0XFF, 0XE1, 0XFF, 0XE0, 0XFF, 0XC0, 0XFF, 0XA0, 0XFF, 0XE0, 0XFF,
0X81, 0XD6, 0XA0, 0X18, 0XC4, 0X18, 0XA1, 0X62, 0XC1, 0XCD, 0X40, 0XFF, 0X60, 0XFE, 0X20, 0XFE,
0XE0, 0XFD, 0XC0, 0XFD, 0X80, 0XFD, 0X80, 0XFD, 0XA0, 0XEC, 0X48, 0XBC, 0XDF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XF9, 0XE6, 0XE3, 0X9A, 0X67, 0XEE, 0XD1, 0XFF, 0XB0, 0XFF, 0X86, 0XFF, 0X60, 0XFF,
0X80, 0XFF, 0XA0, 0XFF, 0XE0, 0XFF, 0X60, 0X94, 0X91, 0X73, 0XD9, 0XBD, 0X00, 0X00, 0X05, 0X84,
0XE8, 0XFF, 0XE5, 0XFF, 0XE3, 0XFF, 0XE1, 0XFF, 0XE0, 0XFF, 0XC0, 0XFF, 0XA0, 0XFF, 0XE0, 0XFF,
0X20, 0XAD, 0XE9, 0X41, 0XB7, 0XB5, 0X01, 0X00, 0X60, 0X62, 0X21, 0XFF, 0X80, 0XFE, 0X20, 0XFE,
0XE0, 0XFD, 0XC0, 0XFD, 0X80, 0XFD, 0X60, 0XFD, 0X20, 0XF5, 0XE3, 0XBB, 0XD9, 0XE6, 0XFF, 0XFF,
0XFF, 0XFF, 0XD3, 0XCD, 0X40, 0XA3, 0X2B, 0XF7, 0XD3, 0XFF, 0XB0, 0XFF, 0X63, 0XFF, 0X60, 0XFF,
0X80, 0XFF, 0XA0, 0XFF, 0XE0, 0XFF, 0XA0, 0X9C, 0X30, 0X6B, 0X97, 0XB5, 0X00, 0X00, 0X83, 0X52,
0XC6, 0XFF, 0XE5, 0XFF, 0XE3, 0XFF, 0XE1, 0XFF, 0XE0, 0XFF, 0XC0, 0XFF, 0XA0, 0XFF, 0XE0, 0XFF,
0X20, 0XAD, 0XEA, 0X41, 0X77, 0XAD, 0X01, 0X00, 0XC0, 0X49, 0XE0, 0XF6, 0XA0, 0XFE, 0X20, 0XFE,
0XE0, 0XFD, 0XC0, 0XFD, 0X80, 0XFD, 0X60, 0XFD, 0X40, 0XFD, 0XA0, 0XBB, 0XD3, 0XCD, 0XFF, 0XFF,
0XFF, 0XFF, 0X50, 0XCD, 0X00, 0XB4, 0X8E, 0XFF, 0XF4, 0XFF, 0XB0, 0XFF, 0X42, 0XFF, 0X60, 0XFF,
0X80, 0XFF, 0XA0, 0XFF, 0XE0, 0XFF, 0XA1, 0XDE, 0X01, 0X21, 0X00, 0X00, 0X00, 0X00, 0X25, 0X8C,
0XE5, 0XFF, 0XE3, 0XFF, 0XE2, 0XFF, 0XE0, 0XFF, 0XE0, 0XFF, 0XC0, 0XFF, 0XA0, 0XFF, 0XE0, 0XFF,
0XE1, 0XDE, 0X01, 0X21, 0X00, 0X00, 0X00, 0X00, 0X61, 0X5A, 0X20, 0XFF, 0X80, 0XFE, 0X20, 0XFE,
0X00, 0XFE, 0XE0, 0XFD, 0XA0, 0XFD, 0X60, 0XFD, 0X60, 0XFD, 0XC0, 0XCB, 0X71, 0XCD, 0XFF, 0XFF,
0XFF, 0XFF, 0X50, 0XCD, 0X40, 0XC4, 0XB0, 0XFF, 0XF5, 0XFF, 0X8F, 0XFF, 0X41, 0XFF, 0X80, 0XFF,
0XA0, 0XFF, 0XC0, 0XFF, 0XE0, 0XFF, 0XE1, 0XFF, 0X21, 0X8C, 0X60, 0X10, 0X43, 0X6B, 0X44, 0XEF,
0XE2, 0XFF, 0XE2, 0XFF, 0XE1, 0XFF, 0XE0, 0XFF, 0XC0, 0XFF, 0XA0, 0XFF, 0X80, 0XFF, 0X80, 0XFF,
0XE1, 0XFF, 0XC1, 0XA4, 0XC2, 0X18, 0XA2, 0X39, 0XA1, 0XCD, 0X20, 0XFF, 0X60, 0XFE, 0X20, 0XFE,
0XC0, 0XFD, 0X80, 0XFD, 0X80, 0XFD, 0X60, 0XFD, 0X60, 0XFD, 0XE0, 0XCB, 0X91, 0XCD, 0XFF, 0XFF,
0XFF, 0XFF, 0X50, 0XCD, 0X40, 0XC4, 0XD2, 0XFF, 0XF7, 0XFF, 0XAF, 0XFF, 0X01, 0XFF, 0X00, 0XFF,
0X00, 0XFF, 0X40, 0XFF, 0XA0, 0XFF, 0XE0, 0XFF, 0XA1, 0XFF, 0X82, 0XD6, 0XC2, 0XFF, 0XE0, 0XFF,
0XE0, 0XFF, 0XE0, 0XFF, 0XE0, 0XFF, 0XC0, 0XFF, 0XC0, 0XFF, 0XA0, 0XFF, 0X80, 0XFF, 0X60, 0XFF,
0X60, 0XFF, 0XC1, 0XFF, 0X82, 0XDE, 0XC2, 0XEE, 0X61, 0XFF, 0X80, 0XFE, 0XC0, 0XFD, 0X20, 0XFD,
0XA1, 0XFC, 0X61, 0XFC, 0X61, 0XFC, 0XC0, 0XFC, 0X60, 0XFD, 0XE0, 0XCB, 0X51, 0XC5, 0XFF, 0XFF,
0XFF, 0XFF, 0X50, 0XCD, 0X60, 0XC4, 0XD4, 0XFF, 0XF9, 0XFF, 0X2D, 0XFF, 0X00, 0XFE, 0XC0, 0XFD,
0XA1, 0XFD, 0X21, 0XFE, 0XE0, 0XFE, 0XC0, 0XFF, 0XE0, 0XFF, 0XE0, 0XFF, 0XE0, 0XFF, 0XE0, 0XFF,
0XE0, 0XFF, 0XE0, 0XFF, 0XC0, 0XFF, 0XC0, 0XFF, 0XA0, 0XFF, 0X80, 0XFF, 0X80, 0XFF, 0X60, 0XFF,
0X40, 0XFF, 0X40, 0XFF, 0X80, 0XFF, 0X20, 0XFF, 0XA0, 0XFE, 0X20, 0XFE, 0X01, 0XFD, 0X01, 0XFC,
0X62, 0XFB, 0X42, 0XFB, 0X82, 0XFB, 0X21, 0XFC, 0X20, 0XFD, 0X00, 0XD4, 0X71, 0XC5, 0XFF, 0XFF,
0XFF, 0XFF, 0X50, 0XCD, 0X20, 0XC4, 0XD4, 0XFF, 0XBA, 0XFF, 0X2E, 0XFE, 0XE1, 0XFC, 0X61, 0XFC,
0X61, 0XFC, 0X01, 0XFD, 0X01, 0XFE, 0X20, 0XFF, 0XA0, 0XFF, 0XA0, 0XFF, 0XC0, 0XFF, 0XC0, 0XFF,
0XC0, 0XFF, 0XC0, 0XFF, 0XA0, 0XFF, 0XA0, 0XFF, 0X80, 0XFF, 0X80, 0XFF, 0X60, 0XFF, 0X40, 0XFF,
0X40, 0XFF, 0X00, 0XFF, 0XC0, 0XFE, 0XA0, 0XFE, 0X80, 0XFE, 0X80, 0XFD, 0X61, 0XFC, 0X62, 0XFB,
0XA3, 0XFA, 0XA3, 0XFA, 0X42, 0XFB, 0X01, 0XFC, 0XE0, 0XFC, 0XE0, 0XCB, 0X71, 0XCD, 0XFF, 0XFF,
0XFF, 0XFF, 0X50, 0XCD, 0XC0, 0XB3, 0XB3, 0XFF, 0X7A, 0XFF, 0X91, 0XFD, 0X03, 0XFC, 0X02, 0XFB,
0X22, 0XFB, 0X62, 0XFC, 0X81, 0XFD, 0XC0, 0XFE, 0XA0, 0XFF, 0XA0, 0XFF, 0XA0, 0XFF, 0XA0, 0XFF,
0XA0, 0XFF, 0XA0, 0XFF, 0X80, 0XFF, 0X80, 0XFF, 0X60, 0XFF, 0X60, 0XFF, 0X40, 0XFF, 0X40, 0XFF,
0X20, 0XFF, 0XE0, 0XFE, 0XC0, 0XFE, 0XA0, 0XFE, 0X60, 0XFE, 0X60, 0XFD, 0X41, 0XFC, 0X62, 0XFB,
0XC3, 0XFA, 0XA3, 0XFA, 0X42, 0XFB, 0X01, 0XFC, 0X20, 0XFD, 0XC0, 0XCB, 0X91, 0XCD, 0XFF, 0XFF,
0XFF, 0XFF, 0X14, 0XD6, 0X20, 0XAB, 0X51, 0XF7, 0XBE, 0XFF, 0X17, 0XFE, 0X65, 0XFC, 0X61, 0XFB,
0XA2, 0XFB, 0XA1, 0XFC, 0XC1, 0XFD, 0X00, 0XFF, 0X80, 0XFF, 0X80, 0XFF, 0X80, 0XFF, 0X80, 0XFF,
0X80, 0XFF, 0X80, 0XFF, 0X80, 0XFF, 0X60, 0XFF, 0X60, 0XFF, 0X60, 0XFF, 0X40, 0XFF, 0X20, 0XFF,
0X00, 0XFF, 0XC0, 0XFE, 0XA0, 0XFE, 0X80, 0XFE, 0X60, 0XFE, 0XC0, 0XFD, 0XC0, 0XFC, 0X41, 0XFC,
0XC1, 0XFB, 0XA2, 0XFB, 0X01, 0XFC, 0XA0, 0XFC, 0X40, 0XFD, 0XA0, 0XC3, 0XF4, 0XD5, 0XFF, 0XFF,
0XFF, 0XFF, 0X5B, 0XEF, 0X24, 0X9B, 0X49, 0XE6, 0XB8, 0XFF, 0X92, 0XFE, 0X25, 0XFD, 0XA0, 0XFC,
0X02, 0XFD, 0XE1, 0XFD, 0XE0, 0XFE, 0X40, 0XFF, 0X60, 0XFF, 0X40, 0XFF, 0X60, 0XFF, 0X60, 0XFF,
0X60, 0XFF, 0X60, 0XFF, 0X40, 0XFF, 0X40, 0XFF, 0X40, 0XFF, 0X40, 0XFF, 0X20, 0XFF, 0X00, 0XFF,
0XC0, 0XFE, 0XA0, 0XFE, 0X80, 0XFE, 0X40, 0XFE, 0X40, 0XFE, 0X00, 0XFE, 0X80, 0XFD, 0X01, 0XF5,
0X41, 0XFD, 0X01, 0XFD, 0XC0, 0XFC, 0X40, 0XFD, 0X00, 0XF5, 0XC4, 0XBB, 0XFA, 0XE6, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0X2A, 0XB4, 0XA0, 0XD4, 0XA2, 0XFE, 0X20, 0XFE, 0XE0, 0XFD, 0X00, 0XFE,
0X80, 0XFE, 0X21, 0XEE, 0X41, 0XE6, 0X40, 0XFF, 0X40, 0XFF, 0X40, 0XFF, 0X40, 0XFF, 0X40, 0XFF,
0X40, 0XFF, 0X40, 0XFF, 0X40, 0XFF, 0X20, 0XFF, 0X20, 0XFF, 0X00, 0XFF, 0XE0, 0XFE, 0XC0, 0XFE,
0XA0, 0XFE, 0X80, 0XFE, 0X60, 0XFE, 0X40, 0XFE, 0X00, 0XFE, 0X00, 0XFE, 0X00, 0XFE, 0X40, 0XCC,
0XE1, 0XAB, 0XC1, 0XED, 0X80, 0XFD, 0X60, 0XFD, 0X60, 0XE4, 0X29, 0XB4, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0X15, 0XD6, 0XE0, 0XBB, 0X60, 0XFE, 0XC8, 0XFE, 0XC8, 0XFE, 0X02, 0XFF,
0X60, 0XDD, 0X40, 0XA3, 0XA1, 0XDD, 0X40, 0XFF, 0X20, 0XFF, 0X20, 0XFF, 0X20, 0XFF, 0X20, 0XFF,
0X20, 0XFF, 0X20, 0XFF, 0X20, 0XFF, 0X00, 0XFF, 0XE0, 0XFE, 0XC0, 0XFE, 0XC0, 0XFE, 0XA0, 0XFE,
0X80, 0XFE, 0X60, 0XFE, 0X40, 0XFE, 0X20, 0XFE, 0X20, 0XFE, 0X20, 0XFE, 0X20, 0XFE, 0X40, 0XED,
0XC0, 0X9A, 0X40, 0XA3, 0X80, 0XF5, 0X60, 0XFD, 0X60, 0XBB, 0XEE, 0XBC, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XDF, 0XFF, 0X63, 0XAB, 0X42, 0XE5, 0XB4, 0XFF, 0X97, 0XFF, 0XAA, 0XF6,
0X80, 0XAB, 0XA0, 0X92, 0XA1, 0XDD, 0X41, 0XFF, 0X40, 0XFF, 0X60, 0XFF, 0X60, 0XFF, 0X60, 0XFF,
0X60, 0XFF, 0X40, 0XFF, 0X40, 0XFF, 0X40, 0XFF, 0X20, 0XFF, 0X20, 0XFF, 0X00, 0XFF, 0XE0, 0XFE,
0XC0, 0XFE, 0X80, 0XFE, 0X61, 0XFE, 0X00, 0XFE, 0XA0, 0XED, 0X20, 0XE5, 0X21, 0XCC, 0X80, 0XB3,
0X00, 0XBC, 0XE0, 0XC3, 0X40, 0XED, 0XC0, 0XEC, 0X60, 0X92, 0X97, 0XE6, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0X0F, 0XC5, 0X00, 0XA3, 0XAA, 0XF6, 0X93, 0XFF, 0X2D, 0XEE,
0X63, 0XDD, 0X80, 0XD5, 0X42, 0XB4, 0X82, 0XCC, 0X00, 0XCD, 0X40, 0XD5, 0XA0, 0XDD, 0XE1, 0XE5,
0XC1, 0XE5, 0XC1, 0XE5, 0XC1, 0XE5, 0XC1, 0XE5, 0X80, 0XDD, 0X60, 0XDD, 0X20, 0XD5, 0XC0, 0XCC,
0XA0, 0XCC, 0X61, 0XC4, 0X21, 0XC4, 0X01, 0XBC, 0X01, 0XBC, 0XE0, 0XBB, 0XC0, 0XBB, 0X60, 0XD4,
0X80, 0XFD, 0X40, 0XFD, 0X80, 0XFD, 0X80, 0XBB, 0X2B, 0XAC, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0X9D, 0XF7, 0X87, 0XA3, 0X60, 0XD4, 0X0A, 0XFF, 0XCF, 0XFE,
0XC9, 0XFE, 0XC0, 0XFE, 0XC0, 0XF6, 0X40, 0XE6, 0X41, 0XCD, 0X42, 0XB4, 0XC1, 0XAB, 0X60, 0XA3,
0X60, 0XA3, 0X80, 0XA3, 0X80, 0XA3, 0X80, 0XA3, 0XA0, 0XAB, 0XC1, 0XAB, 0XE1, 0XB3, 0X22, 0XB4,
0X82, 0XC4, 0XC0, 0XCC, 0X00, 0XD5, 0X60, 0XE5, 0X81, 0XED, 0X80, 0XF5, 0X80, 0XFD, 0X80, 0XFD,
0X40, 0XFD, 0X80, 0XFD, 0X80, 0XE4, 0X85, 0XAB, 0X5C, 0XEF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFA, 0XE6, 0X23, 0XA3, 0XE0, 0XE4, 0XE8, 0XFE,
0X6A, 0XFE, 0X05, 0XFE, 0X40, 0XFE, 0XA0, 0XFE, 0XC0, 0XFE, 0XE1, 0XFE, 0XA0, 0XF6, 0XA0, 0XF6,
0XA0, 0XF6, 0XA0, 0XF6, 0X80, 0XF6, 0X80, 0XF6, 0X80, 0XF6, 0X60, 0XF6, 0X61, 0XFE, 0X81, 0XFE,
0X61, 0XFE, 0X20, 0XFE, 0X00, 0XFE, 0XC0, 0XFD, 0X80, 0XFD, 0X60, 0XFD, 0X20, 0XFD, 0X20, 0XFD,
0X60, 0XFD, 0X20, 0XF5, 0XA0, 0XA2, 0XB4, 0XCD, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0X52, 0XC5, 0XE0, 0XA2, 0XA1, 0XF5,
0X86, 0XFE, 0X06, 0XFE, 0XE2, 0XFD, 0XE0, 0XFD, 0X00, 0XFE, 0X20, 0XFE, 0X20, 0XFE, 0X20, 0XFE,
0X40, 0XFE, 0X20, 0XFE, 0X20, 0XFE, 0X20, 0XFE, 0X00, 0XFE, 0XE0, 0XFD, 0XE0, 0XFD, 0XC0, 0XFD,
0XA0, 0XFD, 0X80, 0XFD, 0X60, 0XFD, 0X40, 0XFD, 0X20, 0XFD, 0X20, 0XFD, 0X20, 0XFD, 0X40, 0XFD,
0X60, 0XFD, 0X60, 0XBB, 0X6C, 0XB4, 0XDE, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0X92, 0XCD, 0XC0, 0XA2,
0X20, 0XED, 0X22, 0XFE, 0XC1, 0XFD, 0XA0, 0XFD, 0XC0, 0XFD, 0XE0, 0XFD, 0XE0, 0XFD, 0XE0, 0XFD,
0XE0, 0XFD, 0XE0, 0XFD, 0XC0, 0XFD, 0XC0, 0XFD, 0XC0, 0XFD, 0XC0, 0XFD, 0XA0, 0XFD, 0X80, 0XFD,
0X80, 0XFD, 0X60, 0XFD, 0X40, 0XFD, 0X20, 0XFD, 0X20, 0XFD, 0X20, 0XFD, 0X60, 0XFD, 0X40, 0XFD,
0X20, 0XB3, 0XEA, 0XA3, 0X9D, 0XF7, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0X8E, 0XBC,
0XE1, 0XA2, 0X00, 0XE5, 0XE0, 0XFD, 0XC0, 0XFD, 0XA0, 0XFD, 0XA0, 0XFD, 0XA0, 0XFD, 0XA0, 0XFD,
0XC0, 0XFD, 0XA0, 0XFD, 0XA0, 0XFD, 0XA0, 0XFD, 0XA0, 0XFD, 0X80, 0XFD, 0X80, 0XFD, 0X60, 0XFD,
0X40, 0XFD, 0X20, 0XFD, 0X20, 0XFD, 0X20, 0XFD, 0X20, 0XFD, 0X80, 0XFD, 0X00, 0XF5, 0X40, 0XBB,
0X2B, 0XAC, 0X9D, 0XF7, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0X35, 0XD6, 0XE2, 0X9A, 0XA0, 0XC3, 0XA0, 0XFD, 0XE0, 0XFD, 0X80, 0XFD, 0X60, 0XFD, 0X80, 0XFD,
0X80, 0XFD, 0X60, 0XFD, 0X60, 0XFD, 0X60, 0XFD, 0X60, 0XFD, 0X60, 0XFD, 0X40, 0XFD, 0X40, 0XFD,
0X20, 0XFD, 0X20, 0XFD, 0X40, 0XFD, 0X60, 0XFD, 0X60, 0XFD, 0X00, 0XD4, 0XC1, 0X9A, 0X10, 0XC5,
0XDE, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0X98, 0XDE, 0X2B, 0XAC, 0X40, 0XB3, 0X00, 0XD4, 0X40, 0XFD, 0X80, 0XFD, 0X80, 0XFD,
0X60, 0XFD, 0X40, 0XFD, 0X40, 0XFD, 0X40, 0XFD, 0X40, 0XFD, 0X40, 0XFD, 0X40, 0XFD, 0X40, 0XFD,
0X40, 0XFD, 0X60, 0XFD, 0X40, 0XFD, 0X40, 0XDC, 0X80, 0XBB, 0XE8, 0XAB, 0X57, 0XDE, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XDF, 0XFF, 0X37, 0XD6, 0X86, 0XA3, 0XC0, 0X9A, 0XE0, 0XCB, 0X80, 0XEC,
0XE0, 0XF4, 0X20, 0XFD, 0X20, 0XFD, 0X20, 0XFD, 0X20, 0XFD, 0X20, 0XFD, 0X20, 0XFD, 0X00, 0XF5,
0XA0, 0XEC, 0X00, 0XD4, 0X40, 0XB3, 0X03, 0X9B, 0X92, 0XC5, 0XBD, 0XF7, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XBE, 0XF7, 0XF5, 0XCD, 0XAD, 0XBC, 0X69, 0XBC,
0X05, 0XBC, 0X03, 0XC4, 0X01, 0XC4, 0X01, 0XC4, 0X01, 0XC4, 0X01, 0XC4, 0XE2, 0XC3, 0X24, 0XC4,
0X68, 0XBC, 0XAC, 0XBC, 0XD3, 0XCD, 0X9E, 0XF7, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0X5B, 0XEF, 0X98, 0XDE, 0X56, 0XD6, 0X57, 0XD6, 0X57, 0XD6, 0X56, 0XD6, 0X77, 0XDE, 0X1B, 0XEF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
};
const unsigned char PROGMEM wifi_full[2048] = {
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x49, 0x21, 0x71, 0xC2, 0x71, 0xC2, 0x71, 0xC2, 0x71, 0xC2,
0x71, 0xC2, 0x71, 0xC2, 0x71, 0xC2, 0x71, 0xC2, 0x71, 0xC2, 0x71, 0xC2, 0x71, 0xC2, 0x71, 0xC2,
0x71, 0xC2, 0x71, 0xC2, 0x71, 0xC2, 0x71, 0xC2, 0x71, 0xC2, 0x71, 0xC2, 0x71, 0xC2, 0x71, 0xC2,
0x71, 0xC2, 0x71, 0xC2, 0x71, 0xC2, 0x71, 0xC2, 0x41, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x28, 0xA0, 0xCB, 0x23, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4,
0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4,
0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4,
0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xC3, 0x03, 0x18, 0x60, 0x00, 0x00,
0x08, 0x20, 0xD3, 0x23, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4,
0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4,
0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4,
0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xC3, 0x03, 0x00, 0x00,
0x59, 0x61, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4,
0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4,
0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4,
0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0x41, 0x01,
0x8A, 0x22, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4,
0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4,
0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4,
0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0x71, 0xC2,
0x92, 0x42, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4,
0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4,
0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4,
0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0x71, 0xC2,
0x92, 0x42, 0xF4, 0x89, 0xFE, 0x34, 0xFE, 0xB7, 0xFF, 0x19, 0xFF, 0x3A, 0xFF, 0x3A, 0xFE, 0xD8,
0xFE, 0x76, 0xF5, 0xD1, 0xF5, 0x0C, 0xEB, 0xE6, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4,
0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4,
0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0x71, 0xC2,
0x92, 0x42, 0xF4, 0xEC, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x19, 0xF5, 0x90, 0xEC, 0x06, 0xEB, 0xA4,
0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4,
0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0x71, 0xC2,
0x92, 0x42, 0xF4, 0x06, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFE, 0x54,
0xF4, 0x47, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4,
0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0x71, 0xC2,
0x92, 0x42, 0xEB, 0xA4, 0xFF, 0x9D, 0xFF, 0xFF, 0xFF, 0xBD, 0xFF, 0x7C, 0xFF, 0x7C, 0xFF, 0x9D,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xF6, 0x13, 0xEB, 0xE5, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4,
0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0x71, 0xC2,
0x92, 0x42, 0xEB, 0xA4, 0xF4, 0x47, 0xEB, 0xE5, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4,
0xEB, 0xC4, 0xF4, 0x48, 0xF5, 0x2E, 0xFE, 0x55, 0xFF, 0xBD, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x7C, 0xF4, 0xAA, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4,
0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0x71, 0xC2,
0x92, 0x42, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4,
0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xC4, 0xF5, 0x0C, 0xFE, 0xF9, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF5, 0xB1, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4,
0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0x71, 0xC2,
0x92, 0x42, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xF4, 0x27, 0xF4, 0xCB, 0xF5, 0x0C, 0xF5, 0x0C,
0xF4, 0xAB, 0xF4, 0x27, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xF4, 0xEC,
0xFF, 0x7C, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFE, 0x34, 0xEB, 0xC4, 0xEB, 0xA4,
0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0x71, 0xC2,
0x92, 0x42, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xFE, 0xF8, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x9D, 0xFE, 0x76, 0xF4, 0xEC, 0xEB, 0xC4, 0xEB, 0xA4, 0xEB, 0xA4,
0xEB, 0xC5, 0xFE, 0x34, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFE, 0x55, 0xEB, 0xA4,
0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0x71, 0xC2,
0x92, 0x42, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xF6, 0x13, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x7C, 0xF5, 0x6F, 0xEB, 0xC4,
0xEB, 0xA4, 0xEB, 0xA4, 0xF5, 0x4E, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF5, 0xF2,
0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0x71, 0xC2,
0x92, 0x42, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xF4, 0x69, 0xF5, 0x0C, 0xF4, 0xAA, 0xF4, 0x89,
0xF4, 0xCB, 0xF5, 0x6F, 0xFE, 0x55, 0xFF, 0x9D, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x1A,
0xF4, 0x48, 0xEB, 0xA4, 0xEB, 0xA4, 0xF5, 0x0C, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xF5, 0x0D, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0x71, 0xC2,
0x92, 0x42, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4,
0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xC4, 0xF4, 0xEC, 0xFF, 0x19, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xDE, 0xF5, 0x0D, 0xEB, 0xA4, 0xEB, 0xA4, 0xF5, 0x4E, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xBE, 0xF4, 0x27, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0x71, 0xC2,
0x92, 0x42, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4,
0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xF5, 0x4E, 0xFF, 0xDE,
0xFF, 0xFF, 0xFF, 0xFF, 0xF5, 0x4E, 0xEB, 0xA4, 0xEB, 0xA4, 0xFE, 0x54, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFE, 0xB7, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0x71, 0xC2,
0x92, 0x42, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xC4, 0xFF, 0x3A, 0xFF, 0x9D,
0xFF, 0x9C, 0xFF, 0x19, 0xF6, 0x13, 0xF4, 0xAA, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xF4, 0x48,
0xFF, 0x7C, 0xFF, 0xFF, 0xFF, 0xFF, 0xF4, 0xEC, 0xEB, 0xA4, 0xEB, 0xC5, 0xFF, 0x7C, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xF4, 0xEC, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0x71, 0xC2,
0x92, 0x42, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xFE, 0xD8, 0xFF, 0x19,
0xFF, 0x19, 0xFF, 0x9C, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x1A, 0xF4, 0xAA, 0xEB, 0xA4, 0xEB, 0xA4,
0xF4, 0x47, 0xFF, 0x9D, 0xFF, 0xFF, 0xFF, 0xBE, 0xF4, 0x47, 0xEB, 0xA4, 0xF4, 0xEC, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x19, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0x71, 0xC2,
0x92, 0x42, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4,
0xEB, 0xA4, 0xEB, 0xA4, 0xF4, 0x27, 0xF5, 0xD1, 0xFF, 0xBD, 0xFF, 0xFF, 0xF5, 0xD2, 0xEB, 0xA4,
0xEB, 0xA4, 0xF4, 0xAA, 0xFF, 0xFF, 0xFF, 0xFF, 0xFE, 0xD8, 0xEB, 0xA4, 0xEB, 0xA4, 0xFE, 0xF9,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF4, 0xCB, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0x71, 0xC2,
0x92, 0x42, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4,
0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEC, 0x06, 0xFE, 0xB7, 0xFF, 0xFF, 0xFE, 0x34,
0xEB, 0xA4, 0xEB, 0xA4, 0xF6, 0x13, 0xFF, 0xFF, 0xFF, 0xFF, 0xF4, 0xEC, 0xEB, 0xA4, 0xF5, 0x0C,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFE, 0x55, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0x71, 0xC2,
0x92, 0x42, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4,
0xF4, 0x27, 0xF5, 0x4E, 0xF5, 0x2D, 0xEB, 0xE5, 0xEB, 0xA4, 0xEB, 0xC4, 0xFE, 0x96, 0xFF, 0xFF,
0xF5, 0x6F, 0xEB, 0xA4, 0xEB, 0xE5, 0xFF, 0xBE, 0xFF, 0xFF, 0xFE, 0xF9, 0xEB, 0xA4, 0xEB, 0xC4,
0xFF, 0x9D, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xDE, 0xEB, 0xC5, 0xEB, 0xA4, 0xEB, 0xA4, 0x71, 0xC2,
0x92, 0x42, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xF4, 0xEC,
0xFF, 0xDF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x9D, 0xEC, 0x48, 0xEB, 0x84, 0xEB, 0xC5, 0xFF, 0x5B,
0xFF, 0xDE, 0xEC, 0x07, 0xE3, 0x84, 0xF5, 0xF3, 0xFF, 0xFF, 0xFF, 0xFF, 0xEC, 0x28, 0xE3, 0x84,
0xF6, 0x14, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xEC, 0xAB, 0xE3, 0x64, 0xE3, 0x64, 0x79, 0xE2,
0xAA, 0x64, 0xB2, 0x84, 0xB2, 0x84, 0xB2, 0x84, 0xB2, 0x84, 0xB2, 0x84, 0xB2, 0xC5, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xEE, 0x98, 0xB2, 0x84, 0xB2, 0x84, 0xC4, 0x0C,
0xFF, 0xFF, 0xDD, 0x93, 0xB2, 0x84, 0xBB, 0x69, 0xFF, 0xFF, 0xFF, 0xFF, 0xD5, 0x11, 0xB2, 0x84,
0xCC, 0x4D, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xDD, 0x32, 0xB2, 0x84, 0xB2, 0x84, 0x92, 0x23,
0xAA, 0x64, 0xB2, 0x84, 0xB2, 0x84, 0xB2, 0x84, 0xB2, 0x84, 0xB2, 0x84, 0xC3, 0x8A, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xDF, 0xB2, 0x84, 0xB2, 0x84, 0xB2, 0x84,
0xF7, 0x3B, 0xFF, 0x9D, 0xB2, 0x85, 0xB2, 0x84, 0xF7, 0x5C, 0xEE, 0xFA, 0xD4, 0xD0, 0xB2, 0x84,
0xB2, 0xE6, 0xDD, 0x93, 0xCC, 0x6E, 0xBB, 0x68, 0xB2, 0x85, 0xB2, 0x84, 0xB2, 0x84, 0x92, 0x23,
0xAA, 0x64, 0xB2, 0x84, 0xB2, 0x84, 0xB2, 0x84, 0xB2, 0x84, 0xB2, 0x84, 0xBB, 0x07, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF7, 0x5C, 0xB2, 0x84, 0xB2, 0x84, 0xB2, 0x84,
0xDD, 0x52, 0xEE, 0xD9, 0xBB, 0x07, 0xB2, 0x84, 0xB2, 0x85, 0xB2, 0x84, 0xB2, 0x84, 0xB2, 0x84,
0xB2, 0x84, 0xB2, 0x84, 0xB2, 0x84, 0xB2, 0x84, 0xB2, 0x84, 0xB2, 0x84, 0xB2, 0x84, 0x92, 0x23,
0xA2, 0x64, 0xB2, 0x84, 0xB2, 0x84, 0xB2, 0x84, 0xB2, 0x84, 0xB2, 0x84, 0xB2, 0x84, 0xE5, 0xD5,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xCC, 0xAF, 0xB2, 0x84, 0xB2, 0x84, 0xB2, 0x84,
0xB2, 0x84, 0xB2, 0x84, 0xB2, 0x84, 0xB2, 0x84, 0xB2, 0x84, 0xB2, 0x84, 0xB2, 0x84, 0xB2, 0x84,
0xB2, 0x84, 0xB2, 0x84, 0xB2, 0x84, 0xB2, 0x84, 0xB2, 0x84, 0xB2, 0x84, 0xB2, 0x84, 0x92, 0x23,
0x9A, 0x43, 0xB2, 0x84, 0xB2, 0x84, 0xB2, 0x84, 0xB2, 0x84, 0xB2, 0x84, 0xB2, 0x84, 0xB2, 0xA5,
0xD4, 0xF0, 0xEE, 0x99, 0xEE, 0x78, 0xCC, 0x4D, 0xB2, 0x84, 0xB2, 0x84, 0xB2, 0x84, 0xB2, 0x84,
0xB2, 0x84, 0xB2, 0x84, 0xB2, 0x84, 0xB2, 0x84, 0xB2, 0x84, 0xB2, 0x84, 0xB2, 0x84, 0xB2, 0x84,
0xB2, 0x84, 0xB2, 0x84, 0xB2, 0x84, 0xB2, 0x84, 0xB2, 0x84, 0xB2, 0x84, 0xB2, 0x84, 0x79, 0xC3,
0x81, 0xE3, 0xB2, 0x84, 0xB2, 0x84, 0xB2, 0x84, 0xB2, 0x84, 0xB2, 0x84, 0xB2, 0x84, 0xB2, 0x84,
0xB2, 0x84, 0xB2, 0x84, 0xB2, 0x84, 0xB2, 0x84, 0xB2, 0x84, 0xB2, 0x84, 0xB2, 0x84, 0xB2, 0x84,
0xB2, 0x84, 0xB2, 0x84, 0xB2, 0x84, 0xB2, 0x84, 0xB2, 0x84, 0xB2, 0x84, 0xB2, 0x84, 0xB2, 0x84,
0xB2, 0x84, 0xB2, 0x84, 0xB2, 0x84, 0xB2, 0x84, 0xB2, 0x84, 0xB2, 0x84, 0xB2, 0x84, 0x59, 0x42,
0x79, 0xC3, 0xB2, 0x84, 0xB2, 0x84, 0xB2, 0x84, 0xB2, 0x84, 0xB2, 0x84, 0xB2, 0x84, 0xB2, 0x84,
0xB2, 0x84, 0xB2, 0x84, 0xB2, 0x84, 0xB2, 0x84, 0xB2, 0x84, 0xB2, 0x84, 0xB2, 0x84, 0xB2, 0x84,
0xB2, 0x84, 0xB2, 0x84, 0xB2, 0x84, 0xB2, 0x84, 0xB2, 0x84, 0xB2, 0x84, 0xB2, 0x84, 0xB2, 0x84,
0xB2, 0x84, 0xB2, 0x84, 0xB2, 0x84, 0xB2, 0x84, 0xB2, 0x84, 0xB2, 0x84, 0xB2, 0x84, 0x59, 0x42,
0x51, 0x42, 0x79, 0xC3, 0x79, 0xC3, 0x9A, 0x23, 0xA2, 0x63, 0xA2, 0x63, 0xA2, 0x63, 0xA2, 0x63,
0xA2, 0x63, 0xA2, 0x63, 0xA2, 0x63, 0xA2, 0x63, 0xA2, 0x63, 0xA2, 0x63, 0xA2, 0x63, 0xA2, 0x63,
0xA2, 0x63, 0xA2, 0x63, 0xA2, 0x63, 0xA2, 0x63, 0xA2, 0x63, 0xA2, 0x63, 0xA2, 0x63, 0xA2, 0x63,
0xA2, 0x63, 0xA2, 0x63, 0xA2, 0x63, 0xA2, 0x63, 0x92, 0x23, 0x79, 0xC3, 0x79, 0xC3, 0x38, 0xE1,
};
libraries/MCUFRIEND_kbv/examples/graphictest_slim/graphictest_slim.ino
+21
View File
@@ -0,0 +1,21 @@
#include <SPI.h> // f.k. for Arduino-1.5.2
#include "Adafruit_GFX.h"// Hardware-specific library
#include <MCUFRIEND_kbv.h>
/*
* an empty Leonardo sketch uses 3.5kB + 4kB bootloader
*
* this C++ program avoids Serial and f-p.
* so it just fits in the Flash.
*
* This is a complete dummy sketch.
* its only purpose is to tell the IDE which libraries to use
*
* The actual program is in the graphictest_v25.cpp
*
* This enables me to build an identical AS7 project
*
* Edit the HOW_SLIM macro to build for other chips
*
*/
libraries/MCUFRIEND_kbv/examples/graphictest_slim/graphictest_v25.cpp
+552
View File
@@ -0,0 +1,552 @@
#if defined(__AVR_ATmega32U4__) //Leonardo
#define HOW_SLIM 3
#else
#define HOW_SLIM 0 //no slimming measures
#endif
// All the mcufriend.com UNO shields have the same pinout.
// i.e. control pins A0-A4. Data D2-D9. microSD D10-D13.
// Touchscreens are normally A1, A2, D7, D6 but the order varies
//
// This demo should work with most Adafruit TFT libraries
// If you are not using a shield, use a full Adafruit constructor()
// e.g. Adafruit_TFTLCD tft(LCD_CS, LCD_CD, LCD_WR, LCD_RD, LCD_RESET);
#define LCD_CS A3 // Chip Select goes to Analog 3
#define LCD_CD A2 // Command/Data goes to Analog 2
#define LCD_WR A1 // LCD Write goes to Analog 1
#define LCD_RD A0 // LCD Read goes to Analog 0
#define LCD_RESET A4 // Can alternately just connect to Arduino's reset pin
#if ARDUINO < 165
#define USE_GFX_KBV
#include "ADA_GFX_kbv.h"
#else
#include "Adafruit_GFX.h"
#endif
#include <MCUFRIEND_kbv.h>
MCUFRIEND_kbv tft;
//#include <Adafruit_TFTLCD.h>
//Adafruit_TFTLCD tft(LCD_CS, LCD_CD, LCD_WR, LCD_RD, LCD_RESET);
// Assign human-readable names to some common 16-bit color values:
#define BLACK 0x0000
#define BLUE 0x001F
#define RED 0xF800
#define GREEN 0x07E0
#define CYAN 0x07FF
#define MAGENTA 0xF81F
#define YELLOW 0xFFE0
#define WHITE 0xFFFF
#ifndef min
#define min(a, b) (((a) < (b)) ? (a) : (b))
#endif
void setup(void);
void loop(void);
unsigned long testFillScreen();
unsigned long testText();
unsigned long testLines(uint16_t color);
unsigned long testFastLines(uint16_t color1, uint16_t color2);
unsigned long testRects(uint16_t color);
unsigned long testFilledRects(uint16_t color1, uint16_t color2);
unsigned long testFilledCircles(uint8_t radius, uint16_t color);
unsigned long testCircles(uint8_t radius, uint16_t color);
unsigned long testTriangles();
unsigned long testFilledTriangles();
unsigned long testRoundRects();
unsigned long testFilledRoundRects();
void progmemPrint(const char *str);
void progmemPrintln(const char *str);
void runtests(void);
uint16_t g_identifier;
void setup(void) {
#if HOW_SLIM < 1
Serial.begin(9600);
uint32_t when = millis();
// while (!Serial) ; //hangs a Leonardo until you connect a Serial
if (!Serial) delay(5000); //allow some time for Leonardo
Serial.println("Serial took " + String((millis() - when)) + "ms to start");
#endif
static uint16_t identifier;
tft.reset(); //we can't read ID on 9341 until begin()
g_identifier = tft.readID(); //
#if HOW_SLIM < 1
Serial.print("ID = 0x");
Serial.println(g_identifier, HEX);
#endif
if (g_identifier == 0x00D3) g_identifier = 0x9481; // write-only shield
if (g_identifier == 0xFFFF) g_identifier = 0x9341; // serial
// g_identifier = 0x7789; // force ID
tft.begin(g_identifier);
}
#if defined(MCUFRIEND_KBV_H_)
uint16_t scrollbuf[480]; // my biggest screen is 320x480
#define READGRAM(x, y, buf, w, h) tft.readGRAM(x, y, buf, w, h)
#else
uint16_t scrollbuf[320]; // Adafruit only does 240x320
// Adafruit can read a block by one pixel at a time
int16_t READGRAM(int16_t x, int16_t y, uint16_t *block, int16_t w, int16_t h)
{
uint16_t *p;
for (int row = 0; row < h; row++) {
p = block + row * w;
for (int col = 0; col < w; col++) {
*p++ = tft.readPixel(x + col, y + row);
}
}
}
#endif
void windowScroll(int16_t x, int16_t y, int16_t wid, int16_t ht, int16_t dx, int16_t dy, uint16_t *buf)
{
if (dx) for (int16_t row = 0; row < ht; row++) {
READGRAM(x, y + row, buf, wid, 1);
tft.setAddrWindow(x, y + row, x + wid - 1, y + row);
tft.pushColors(buf + dx, wid - dx, 1);
tft.pushColors(buf + 0, dx, 0);
}
if (dy) for (int16_t col = 0; col < wid; col++) {
READGRAM(x + col, y, buf, 1, ht);
tft.setAddrWindow(x + col, y, x + col, y + ht - 1);
tft.pushColors(buf + dy, ht - dy, 1);
tft.pushColors(buf + 0, dy, 0);
}
}
void loop(void) {
uint8_t aspect;
uint16_t pixel;
char *aspectname[] = {
"PORTRAIT", "LANDSCAPE", "PORTRAIT_REV", "LANDSCAPE_REV"
};
char *colorname[] = { "BLUE", "GREEN", "RED", "GRAY" };
uint16_t colormask[] = { 0x001F, 0x07E0, 0xF800, 0xFFFF };
uint16_t dx, rgb, n, wid, ht;
tft.setRotation(1);
runtests();
delay(2000);
if (tft.height() > 64) {
for (uint8_t cnt = 0; cnt < 4; cnt++) {
aspect = (cnt + 0) & 3;
tft.setRotation(aspect);
wid = tft.width();
ht = tft.height();
testText();
dx = wid / 32;
for (n = 0; n < 32; n++) {
rgb = n * 8;
rgb = tft.color565(rgb, rgb, rgb);
tft.fillRect(n * dx, 48, dx, 64, rgb & colormask[aspect]);
}
tft.setTextSize(2);
tft.setTextColor(colormask[aspect], BLACK);
tft.setCursor(0, 72);
tft.print(colorname[aspect]);
tft.setTextColor(WHITE);
tft.println(" COLOR GRADES");
tft.setTextColor(WHITE, BLACK);
tft.setCursor(0, 184);
tft.println(aspectname[aspect]);
delay(1000);
tft.drawPixel(0, 0, YELLOW);
pixel = tft.readPixel(0, 0);
#if defined(MCUFRIEND_KBV_H_)
#if HOW_SLIM < 3
extern const uint8_t penguin[];
tft.setAddrWindow(wid - 40 - 40, 20 + 0, wid - 1 - 40, 20 + 39);
tft.pushColors(penguin, 1600, 1);
#endif
tft.setTextColor(WHITE, BLACK);
tft.println("VERTICAL SCROLL UP");
uint16_t maxscroll;
if (tft.getRotation() & 1) maxscroll = wid;
else maxscroll = ht;
for (uint16_t i = 1; i <= maxscroll; i++) {
tft.vertScroll(0, maxscroll, i);
delay(10);
}
tft.vertScroll(0, maxscroll, 0);
tft.setCursor(0, 200);
tft.println("VERTICAL SCROLL DN");
for (uint16_t i = 1; i <= maxscroll; i++) {
tft.vertScroll(0, maxscroll, 0 - (int16_t)i);
delay(10);
}
delay(1000);
tft.vertScroll(0, maxscroll, 0);
if ((aspect & 1) == 0) { //Portrait
tft.setCursor(0, 200);
tft.setTextColor(BLUE, BLACK);
tft.println("ONLY THE COLOR BAND");
for (uint16_t i = 0; i < 64; i++) {
tft.vertScroll(48, 64, i + 1);
delay(20);
}
delay(1000);
tft.vertScroll(0, maxscroll, 0);
}
#endif
tft.setCursor(0, 200);
tft.setTextColor(YELLOW, BLACK);
if (pixel == YELLOW) {
tft.println("SOFTWARE SCROLL ");
#if 1
for (int16_t i = 45, dx = 2, dy = 1; i > 0; i -= dx) {
windowScroll(24, 8, 90, 40, dx, dy, scrollbuf);
}
#else
// scroll a whole width of the screen
for (int16_t i = wid, dx = 4, dy = 0; i > 0; i -= dx) {
windowScroll(0, 200, wid, 16, dx, dy, scrollbuf);
}
#endif
}
else if (pixel == CYAN)
tft.println("readPixel() reads as BGR");
else if (pixel == 0xFFFF)
tft.println("readPixel() should be 24-bit");
else {
tft.print("readPixel() reads 0x");
tft.println(pixel, HEX);
}
delay(5000);
}
}
tft.println("INVERT DISPLAY");
tft.invertDisplay(true);
delay(2000);
tft.invertDisplay(false);
}
typedef struct {
PGM_P msg;
uint32_t ms;
} TEST;
TEST result[12];
#define RUNTEST(n, str, test) { result[n].msg = PSTR(str); result[n].ms = test; delay(500); }
void runtests(void)
{
uint8_t i;
uint32_t total;
RUNTEST(0, "FillScreen ", testFillScreen());
RUNTEST(1, "Text ", testText());
RUNTEST(2, "Lines ", testLines(CYAN));
RUNTEST(3, "Horiz/Vert Lines ", testFastLines(RED, BLUE));
RUNTEST(4, "Rectangles (outline) ", testRects(GREEN));
RUNTEST(5, "Rectangles (filled) ", testFilledRects(YELLOW, MAGENTA));
RUNTEST(6, "Circles (filled) ", testFilledCircles(10, MAGENTA));
RUNTEST(7, "Circles (outline) ", testCircles(10, WHITE));
RUNTEST(8, "Triangles (outline) ", testTriangles());
RUNTEST(9, "Triangles (filled) ", testFilledTriangles());
RUNTEST(10, "Rounded rects (outline) ", testRoundRects());
RUNTEST(11, "Rounded rects (filled) ", testFilledRoundRects());
tft.setRotation(1);
tft.fillScreen(BLACK);
tft.setCursor(0, 0);
tft.setTextSize(2);
tft.println("MCUFRIEND for UNO");
tft.setTextSize(1);
total = 0;
for (i = 0; i < 12; i++) {
PGM_P str = result[i].msg;
char c;
if (i < 10) tft.print(" ");
tft.print(i);
tft.print(": ");
while (c = pgm_read_byte(str++)) tft.print(c);
tft.println(result[i].ms);
total += result[i].ms;
}
tft.setTextSize(2);
tft.print("Total:");
#if HOW_SLIM < 2
tft.print(0.000001 * total);
tft.println("sec");
#else
tft.print(total / 1000, DEC);
tft.println(" ms");
#endif
g_identifier = tft.readID();
tft.print("ID: 0x");
tft.println(tft.readID(), HEX);
tft.print("Reg(00):0x");
tft.println(tft.readReg(0x00), HEX);
tft.print("F_CPU:");
#if HOW_SLIM < 2
tft.print(0.000001 * F_CPU);
#else
tft.print((int)(F_CPU/1000000));
#endif
#if defined(__OPTIMIZE_SIZE__)
tft.println("MHz -Os");
#else
tft.println("MHz");
#endif
delay(10000);
}
// Standard Adafruit tests. will adjust to screen size
unsigned long testFillScreen() {
unsigned long start = micros();
tft.fillScreen(BLACK);
tft.fillScreen(RED);
tft.fillScreen(GREEN);
tft.fillScreen(BLUE);
tft.fillScreen(BLACK);
return micros() - start;
}
unsigned long testText() {
unsigned long start;
tft.fillScreen(BLACK);
start = micros();
tft.setCursor(0, 0);
tft.setTextColor(WHITE); tft.setTextSize(1);
tft.println("Hello World!");
tft.setTextColor(YELLOW); tft.setTextSize(2);
#if HOW_SLIM < 2
tft.println(123.45);
#else
tft.println("456.78");
#endif
tft.setTextColor(RED); tft.setTextSize(3);
tft.println(0xDEADBEEF, HEX);
tft.println();
tft.setTextColor(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(BLACK);
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
tft.fillScreen(BLACK);
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;
tft.fillScreen(BLACK);
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;
tft.fillScreen(BLACK);
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);
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(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(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(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);
}
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(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(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(0, 0, 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(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, i));
t += micros() - start;
tft.drawTriangle(cx, cy - i, cx - i, cy + i, cx + i, cy + i,
tft.color565(i, i, 0));
}
return t;
}
unsigned long testRoundRects() {
unsigned long start;
int w, i, i2, red, step,
cx = tft.width() / 2 - 1,
cy = tft.height() / 2 - 1;
tft.fillScreen(BLACK);
w = min(tft.width(), tft.height());
start = micros();
red = 0;
step = (256 * 6) / w;
for (i = 0; i < w; i += 6) {
i2 = i / 2;
red += step;
tft.drawRoundRect(cx - i2, cy - i2, i, i, i / 8, tft.color565(red, 0, 0));
}
return micros() - start;
}
unsigned long testFilledRoundRects() {
unsigned long start;
int i, i2, green, step,
cx = tft.width() / 2 - 1,
cy = tft.height() / 2 - 1;
tft.fillScreen(BLACK);
start = micros();
green = 256;
step = (256 * 6) / min(tft.width(), tft.height());
for (i = min(tft.width(), tft.height()); i > 20; i -= 6) {
i2 = i / 2;
green -= step;
tft.fillRoundRect(cx - i2, cy - i2, i, i, i / 8, tft.color565(0, green, 0));
}
return micros() - start;
}
libraries/MCUFRIEND_kbv/examples/graphictest_slim/icons.c
+408
View File
@@ -0,0 +1,408 @@
#include <Arduino.h>
const unsigned char PROGMEM penguin[3200] = { /* 0X00,0X10,0X28,0X00,0X28,0X00,0X01,0X1B, */
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XBE, 0XF7, 0X7D, 0XEF,
0XBA, 0XD6, 0XB6, 0XB5, 0XF3, 0X9C, 0XB2, 0X94, 0XB3, 0X9C, 0XB2, 0X94, 0X34, 0XA5, 0XF7, 0XBD,
0XFB, 0XDE, 0X7D, 0XEF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XBE, 0XF7, 0XFB, 0XDE, 0XF3, 0X9C, 0XCB, 0X5A,
0XC7, 0X39, 0X04, 0X21, 0X82, 0X10, 0X42, 0X10, 0X42, 0X10, 0X41, 0X08, 0X83, 0X18, 0X45, 0X29,
0XC7, 0X39, 0X0C, 0X63, 0X75, 0XAD, 0X3C, 0XE7, 0XBE, 0XF7, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0X3C, 0XE7, 0XB2, 0X94, 0X08, 0X42, 0XC3, 0X18, 0X82, 0X10,
0X04, 0X21, 0X45, 0X29, 0X86, 0X31, 0X86, 0X31, 0X86, 0X31, 0X86, 0X31, 0X45, 0X29, 0X04, 0X21,
0X82, 0X10, 0X41, 0X08, 0XC3, 0X18, 0X08, 0X42, 0XF3, 0X9C, 0X3C, 0XE7, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFB, 0XDE, 0X0C, 0X63, 0XC3, 0X18, 0XC3, 0X18, 0X45, 0X29, 0XC7, 0X39,
0X08, 0X42, 0X08, 0X42, 0X08, 0X42, 0X08, 0X42, 0X08, 0X42, 0X08, 0X42, 0XC7, 0X39, 0XC7, 0X39,
0X86, 0X31, 0X86, 0X31, 0X04, 0X21, 0X41, 0X08, 0X82, 0X10, 0XCB, 0X5A, 0XBA, 0XD6, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFB, 0XDE, 0XCB, 0X5A, 0X82, 0X10, 0X45, 0X29, 0XC7, 0X39, 0X08, 0X42, 0X08, 0X42,
0X09, 0X4A, 0X49, 0X4A, 0X49, 0X4A, 0X49, 0X4A, 0X49, 0X4A, 0X49, 0X4A, 0X08, 0X42, 0XC7, 0X39,
0XC7, 0X39, 0XC7, 0X39, 0X86, 0X31, 0X45, 0X29, 0X83, 0X18, 0X00, 0X00, 0XC8, 0X41, 0X38, 0XC6,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0X7D, 0XEF, 0X8E, 0X73, 0X82, 0X10, 0X45, 0X29, 0XC7, 0X39, 0X08, 0X42, 0X09, 0X4A, 0X8A, 0X52,
0X30, 0X84, 0XCF, 0X7B, 0X8A, 0X52, 0X49, 0X4A, 0X4A, 0X52, 0X49, 0X4A, 0XCB, 0X5A, 0XCF, 0X7B,
0X0C, 0X63, 0X08, 0X42, 0XC7, 0X39, 0X86, 0X31, 0X45, 0X29, 0XC3, 0X18, 0X00, 0X00, 0X49, 0X4A,
0XBA, 0XD6, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XF3, 0X9C, 0XC3, 0X18, 0X04, 0X21, 0XC7, 0X39, 0X08, 0X42, 0X49, 0X4A, 0X49, 0X4A, 0X72, 0X94,
0X7D, 0XEF, 0X7D, 0XEF, 0XB2, 0X94, 0X4A, 0X52, 0X49, 0X4A, 0X8A, 0X52, 0X75, 0XAD, 0XBE, 0XF7,
0XBA, 0XD6, 0X4D, 0X6B, 0XC7, 0X39, 0XC7, 0X39, 0X86, 0X31, 0X45, 0X29, 0XC3, 0X18, 0X41, 0X08,
0XCF, 0X7B, 0X7C, 0XE7, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XBA, 0XD6,
0X08, 0X42, 0X82, 0X10, 0XC7, 0X39, 0X08, 0X42, 0X49, 0X4A, 0X49, 0X4A, 0X8E, 0X73, 0XFB, 0XDE,
0XFF, 0XFF, 0XBE, 0XF7, 0XBA, 0XD6, 0X8E, 0X73, 0X08, 0X42, 0X30, 0X84, 0X3C, 0XE7, 0X7D, 0XEF,
0XFF, 0XFF, 0XB6, 0XB5, 0X49, 0X4A, 0XC7, 0X39, 0X86, 0X31, 0X45, 0X29, 0X04, 0X21, 0X41, 0X08,
0X45, 0X29, 0XB6, 0XB5, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XBE, 0XF7, 0X71, 0X8C,
0X41, 0X08, 0X45, 0X29, 0X08, 0X42, 0X49, 0X4A, 0X49, 0X4A, 0X4A, 0X52, 0XB2, 0X94, 0XBE, 0XF7,
0XBE, 0XF7, 0XB2, 0X94, 0XCF, 0X7B, 0XCF, 0X7B, 0X49, 0X4A, 0XB6, 0XB5, 0XF3, 0X9C, 0X0C, 0X63,
0X38, 0XC6, 0XBA, 0XD6, 0X0C, 0X63, 0X87, 0X39, 0XC7, 0X39, 0X86, 0X31, 0X45, 0X29, 0XC3, 0X18,
0X41, 0X08, 0X30, 0X84, 0X7D, 0XEF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0X3C, 0XE7, 0XCB, 0X5A,
0X41, 0X08, 0XC7, 0X39, 0X08, 0X42, 0X49, 0X4A, 0X4A, 0X52, 0X8A, 0X52, 0XF3, 0X9C, 0XFF, 0XFF,
0X7D, 0XEF, 0XC7, 0X39, 0XC3, 0X18, 0X0C, 0X63, 0XCB, 0X5A, 0XB6, 0XB5, 0XB2, 0X94, 0XCB, 0X5A,
0X75, 0XAD, 0XFA, 0XD6, 0X4D, 0X6B, 0X87, 0X39, 0XC7, 0X39, 0X86, 0X31, 0X45, 0X29, 0X04, 0X21,
0X41, 0X08, 0X8A, 0X52, 0X79, 0XCE, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0X38, 0XC6, 0X86, 0X31,
0X04, 0X21, 0XC8, 0X41, 0X49, 0X4A, 0X49, 0X4A, 0X4A, 0X52, 0X49, 0X4A, 0XB1, 0X8C, 0XBE, 0XF7,
0XBE, 0XF7, 0XB2, 0X94, 0XCF, 0X7B, 0XCF, 0X7B, 0X49, 0X4A, 0X74, 0XA5, 0X7D, 0XEF, 0X7C, 0XE7,
0XBE, 0XF7, 0X79, 0XCE, 0X0C, 0X63, 0XC7, 0X39, 0XC7, 0X39, 0X86, 0X31, 0X45, 0X29, 0X04, 0X21,
0X82, 0X10, 0X45, 0X29, 0X75, 0XAD, 0XBE, 0XF7, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0X34, 0XA5, 0X82, 0X10,
0X86, 0X31, 0X08, 0X42, 0X49, 0X4A, 0X49, 0X4A, 0X8A, 0X52, 0X49, 0X4A, 0X4D, 0X6B, 0XBA, 0XD6,
0XFF, 0XFF, 0XFF, 0XFF, 0X79, 0XCE, 0X0D, 0X63, 0XC7, 0X39, 0XCF, 0X7B, 0X7D, 0XEF, 0XFF, 0XFF,
0XFF, 0XFF, 0X75, 0XAD, 0X08, 0X42, 0X86, 0X31, 0XC7, 0X39, 0X86, 0X31, 0X45, 0X29, 0X45, 0X29,
0XC3, 0X18, 0XC3, 0X18, 0XB2, 0X94, 0X7D, 0XEF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XBE, 0XF7, 0XB2, 0X8C, 0X41, 0X08,
0XC7, 0X39, 0X08, 0X42, 0X49, 0X4A, 0X49, 0X4A, 0X8A, 0X52, 0X8A, 0X52, 0X4A, 0X4A, 0XD0, 0X7B,
0X7A, 0XC6, 0X7B, 0XBE, 0X90, 0X6B, 0XC9, 0X39, 0X88, 0X31, 0XC9, 0X39, 0XB3, 0X84, 0XBB, 0XC6,
0XF8, 0XB5, 0XCC, 0X5A, 0X86, 0X31, 0XC7, 0X39, 0XC7, 0X39, 0X86, 0X31, 0X45, 0X29, 0X45, 0X29,
0XC4, 0X20, 0X41, 0X08, 0X30, 0X84, 0X3C, 0XE7, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0X3C, 0XE7, 0X8A, 0X4A, 0XC3, 0X10,
0XC7, 0X39, 0X08, 0X42, 0X49, 0X4A, 0X49, 0X4A, 0X4A, 0X4A, 0X4A, 0X42, 0X09, 0X3A, 0X08, 0X4A,
0X09, 0X6B, 0X49, 0X7B, 0XC6, 0X7A, 0X05, 0X83, 0X46, 0X83, 0XC5, 0X7A, 0XC6, 0X72, 0X09, 0X7B,
0X48, 0X5A, 0X87, 0X31, 0X88, 0X21, 0X88, 0X29, 0X86, 0X31, 0X86, 0X31, 0X45, 0X29, 0X45, 0X29,
0X04, 0X21, 0X41, 0X08, 0X4A, 0X4A, 0XBA, 0XD6, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XF7, 0XC5, 0X82, 0X50, 0X05, 0X41,
0XC7, 0X29, 0X08, 0X42, 0X49, 0X4A, 0X4A, 0X42, 0X49, 0X4A, 0X09, 0X7B, 0X88, 0X9B, 0XC6, 0XB3,
0X21, 0XD4, 0XA0, 0XDC, 0XE1, 0XE4, 0X61, 0XED, 0X61, 0XED, 0X21, 0XED, 0XA0, 0XE4, 0X20, 0XDC,
0X80, 0XCB, 0X43, 0XAB, 0XC4, 0X82, 0X06, 0X5A, 0X47, 0X21, 0X46, 0X29, 0X45, 0X29, 0X04, 0X29,
0X04, 0X19, 0X82, 0X10, 0X82, 0X18, 0XF3, 0X9C, 0X7D, 0XEF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0X7D, 0XEF, 0X4D, 0X93, 0X00, 0XA0, 0X82, 0XB8,
0XC7, 0X31, 0X09, 0X32, 0X49, 0X4A, 0X86, 0X7A, 0X43, 0XC3, 0X6B, 0XED, 0XF4, 0XF6, 0XEB, 0XFD,
0X20, 0XFD, 0X20, 0XFD, 0X60, 0XFD, 0XA0, 0XFD, 0XA0, 0XFD, 0X60, 0XFD, 0X60, 0XFD, 0X20, 0XFD,
0XE0, 0XFC, 0XA0, 0XFC, 0X60, 0XF4, 0XC1, 0XDB, 0X83, 0X9A, 0XC5, 0X49, 0X45, 0X29, 0X04, 0X19,
0XC4, 0X20, 0X82, 0X38, 0X00, 0X50, 0XCB, 0X6A, 0XBA, 0XD6, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFB, 0XEE, 0X04, 0XA1, 0X00, 0XC0, 0X00, 0XF0,
0XC3, 0XA0, 0XC8, 0X41, 0X49, 0X42, 0X05, 0X9B, 0X20, 0XFC, 0XA4, 0XFC, 0X69, 0XFD, 0XE8, 0XFD,
0X63, 0XFD, 0X20, 0XFD, 0X60, 0XFD, 0X60, 0XFD, 0X60, 0XFD, 0X20, 0XFD, 0X20, 0XFD, 0XE0, 0XFC,
0XE0, 0XFC, 0XA0, 0XFC, 0X60, 0XFC, 0X20, 0XFC, 0X41, 0XD3, 0XC5, 0X49, 0X45, 0X19, 0XC4, 0X38,
0X82, 0X68, 0X41, 0X88, 0X00, 0X70, 0X49, 0X5A, 0X79, 0XCE, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFB, 0XF6, 0X82, 0XC0, 0X00, 0XD0, 0X86, 0XC1,
0X46, 0XF1, 0X41, 0XC8, 0X45, 0X79, 0X89, 0X52, 0X88, 0X62, 0X86, 0X6A, 0XC6, 0X7A, 0XC4, 0XBB,
0XE1, 0XFC, 0X60, 0XFD, 0X60, 0XFD, 0XA0, 0XFD, 0XA0, 0XFD, 0X60, 0XFD, 0X60, 0XFD, 0XE0, 0XFC,
0X60, 0XE4, 0X03, 0X93, 0X84, 0X72, 0X44, 0X6A, 0XC5, 0X41, 0X45, 0X29, 0XC3, 0X58, 0X41, 0XA8,
0X40, 0X98, 0X00, 0XB0, 0X00, 0X60, 0X0C, 0X6B, 0X79, 0XCE, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0X7D, 0XEF, 0XCE, 0X83, 0X82, 0X88, 0X00, 0XF8, 0XC4, 0XD8,
0X0C, 0XF3, 0X8A, 0XFA, 0X82, 0XE8, 0X82, 0XB0, 0X45, 0X69, 0XC7, 0X51, 0X08, 0X42, 0X08, 0X3A,
0X86, 0X5A, 0X83, 0X9B, 0XA2, 0XBC, 0X22, 0XCD, 0X21, 0XCD, 0XA1, 0XC4, 0X22, 0XB4, 0XC4, 0X7A,
0X06, 0X3A, 0X86, 0X29, 0X45, 0X29, 0X05, 0X31, 0XC4, 0X50, 0X41, 0X90, 0X00, 0XC0, 0X00, 0XA8,
0X00, 0XA0, 0X00, 0XA8, 0X00, 0X30, 0X4A, 0X4A, 0XBA, 0XD6, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0X7D, 0XEF, 0X8E, 0X73, 0XC3, 0X18, 0X05, 0X39, 0X82, 0XA8, 0X00, 0XF8,
0XC3, 0XF8, 0X4D, 0XFB, 0X4D, 0XFB, 0XC7, 0XF9, 0XC3, 0XF0, 0X82, 0XD8, 0XC3, 0XB0, 0X04, 0X81,
0X45, 0X61, 0X46, 0X51, 0X86, 0X49, 0X86, 0X49, 0X46, 0X41, 0X45, 0X41, 0X45, 0X41, 0X45, 0X41,
0X05, 0X49, 0X04, 0X61, 0X82, 0X90, 0X41, 0XB0, 0X00, 0XD0, 0X00, 0XC8, 0X00, 0XA8, 0X00, 0XA8,
0X00, 0XB8, 0X41, 0X58, 0X82, 0X10, 0X82, 0X10, 0XB2, 0X94, 0XBE, 0XF7, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XBE, 0XF7, 0XCF, 0X7B, 0X82, 0X10, 0X04, 0X21, 0X86, 0X29, 0X86, 0X41, 0X04, 0X99,
0X40, 0XE8, 0X41, 0XF8, 0X86, 0XF9, 0XCB, 0XFA, 0X49, 0XFA, 0X82, 0XF8, 0X00, 0XF8, 0X00, 0XF0,
0X00, 0XE8, 0X41, 0XD8, 0X41, 0XD0, 0X41, 0XC0, 0X41, 0XC0, 0X41, 0XC0, 0X41, 0XC0, 0X41, 0XC8,
0X00, 0XD0, 0X00, 0XE0, 0X00, 0XE0, 0X00, 0XD8, 0X00, 0XD0, 0X00, 0XB8, 0X00, 0XA8, 0X41, 0X88,
0X82, 0X48, 0X82, 0X10, 0X82, 0X10, 0X00, 0X00, 0X45, 0X29, 0X79, 0XCE, 0XFF, 0XFF, 0XFF, 0XFF,
0XBE, 0XF7, 0XF3, 0X9C, 0X82, 0X10, 0XC3, 0X18, 0X45, 0X29, 0X86, 0X31, 0XC7, 0X31, 0X30, 0X7C,
0XF3, 0XDC, 0X86, 0XE1, 0X00, 0XF0, 0X00, 0XF8, 0X41, 0XF8, 0X41, 0XF8, 0X00, 0XF8, 0X00, 0XF8,
0X00, 0XF8, 0X00, 0XF8, 0X00, 0XF8, 0X00, 0XF8, 0X00, 0XF8, 0X00, 0XF8, 0X00, 0XF8, 0X00, 0XF8,
0X00, 0XE8, 0X00, 0XE0, 0X00, 0XE0, 0X00, 0XD8, 0X00, 0XC8, 0X41, 0XA0, 0X8A, 0X9A, 0X0C, 0X63,
0X04, 0X11, 0X82, 0X10, 0X82, 0X10, 0X41, 0X08, 0X00, 0X00, 0X4D, 0X6B, 0X7D, 0XEF, 0XFF, 0XFF,
0XFB, 0XDE, 0X08, 0X42, 0X42, 0X10, 0X45, 0X29, 0X86, 0X31, 0X86, 0X31, 0X49, 0X4A, 0X38, 0XBE,
0XFF, 0XFF, 0X38, 0XD6, 0X86, 0XA9, 0X00, 0XC8, 0X00, 0XE0, 0X00, 0XF0, 0X00, 0XF8, 0X00, 0XF8,
0X00, 0XF8, 0X00, 0XF8, 0X00, 0XF8, 0X00, 0XF8, 0X00, 0XF8, 0X00, 0XF8, 0X00, 0XF0, 0X00, 0XF0,
0X00, 0XE8, 0X00, 0XE0, 0X00, 0XD0, 0XC3, 0X98, 0X8A, 0X8A, 0XB2, 0XA4, 0XBA, 0XC6, 0XF7, 0XB5,
0X08, 0X42, 0X41, 0X08, 0X82, 0X10, 0X41, 0X08, 0X00, 0X00, 0X45, 0X29, 0XF7, 0XBD, 0XFF, 0XFF,
0X71, 0X8C, 0X41, 0X08, 0X04, 0X21, 0X45, 0X29, 0X86, 0X31, 0X86, 0X31, 0X0C, 0X63, 0X3C, 0XE7,
0XFF, 0XFF, 0X79, 0XD6, 0X46, 0XB9, 0X00, 0XE0, 0X42, 0XC8, 0X82, 0XA8, 0X82, 0XB0, 0X41, 0XD8,
0X82, 0XE8, 0X82, 0XF0, 0X41, 0XE8, 0X41, 0XE8, 0X41, 0XE8, 0X41, 0XF0, 0X41, 0XE8, 0X41, 0XD8,
0X04, 0XC1, 0X08, 0X92, 0X4D, 0X8B, 0X34, 0XA5, 0XFB, 0XC6, 0XFB, 0XD6, 0XBA, 0XCE, 0X3C, 0XE7,
0X30, 0X84, 0XC3, 0X18, 0X41, 0X08, 0X41, 0X08, 0X00, 0X00, 0X41, 0X08, 0XCF, 0X7B, 0X7D, 0XEF,
0X49, 0X4A, 0X00, 0X00, 0X04, 0X21, 0X45, 0X29, 0X46, 0X31, 0X86, 0X31, 0X30, 0X84, 0XFF, 0XFF,
0XFF, 0XF7, 0XF7, 0XDD, 0X09, 0XDA, 0X83, 0XF8, 0X01, 0XF0, 0X42, 0XC0, 0X82, 0X98, 0X49, 0X9A,
0XF3, 0XB4, 0XF3, 0XCC, 0X71, 0XBC, 0X8E, 0XBB, 0X8E, 0XBB, 0X30, 0XBC, 0X71, 0XBC, 0XF3, 0XBC,
0XB6, 0XBD, 0XFB, 0XCE, 0XBE, 0XE7, 0X7D, 0XE7, 0X3B, 0XDF, 0XBA, 0XD6, 0X79, 0XCE, 0XFB, 0XDE,
0X75, 0XAD, 0X86, 0X31, 0X41, 0X08, 0X41, 0X08, 0X00, 0X00, 0X00, 0X00, 0X49, 0X4A, 0XFB, 0XDE,
0X04, 0X21, 0X41, 0X08, 0X04, 0X21, 0X45, 0X29, 0X45, 0X29, 0X87, 0X39, 0XB2, 0X94, 0XFF, 0XFF,
0XBE, 0XF7, 0X34, 0XDD, 0X0C, 0XEB, 0X09, 0XFA, 0X00, 0XF0, 0X01, 0XD8, 0X00, 0XD8, 0X8B, 0XD2,
0X7D, 0XE7, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XBE, 0XFF, 0X7D, 0XEF, 0XFB, 0XDE, 0XFB, 0XDE, 0XBA, 0XD6, 0X79, 0XCE, 0XBA, 0XD6,
0X78, 0XC6, 0XC7, 0X39, 0X00, 0X00, 0X41, 0X08, 0X00, 0X00, 0X00, 0X00, 0XC7, 0X39, 0X79, 0XCE,
0X00, 0X00, 0X82, 0X10, 0XC3, 0X18, 0X04, 0X21, 0X05, 0X29, 0X86, 0X31, 0XB3, 0X9C, 0XFF, 0XFF,
0XFF, 0XF7, 0X75, 0XDD, 0XC7, 0XE9, 0XC7, 0XF9, 0X01, 0XF8, 0X01, 0XF0, 0X00, 0XE8, 0X49, 0XE2,
0XFB, 0XEE, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XBE, 0XF7, 0X7D, 0XEF, 0XFB, 0XDE, 0XFB, 0XDE, 0XBA, 0XD6, 0X79, 0XCE, 0XBA, 0XD6,
0XB9, 0XCE, 0X08, 0X42, 0X00, 0X00, 0X00, 0X00, 0X00, 0X00, 0X00, 0X00, 0XC7, 0X39, 0X38, 0XC6,
0X00, 0X00, 0X82, 0X10, 0X82, 0X10, 0X04, 0X21, 0X04, 0X21, 0X45, 0X29, 0X30, 0X84, 0XFF, 0XFF,
0XFF, 0XFF, 0X38, 0XDE, 0XC4, 0XD0, 0X00, 0XF0, 0X01, 0XF8, 0X00, 0XF8, 0X00, 0XF0, 0X08, 0XD2,
0XFB, 0XE6, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XBE, 0XF7, 0X7D, 0XEF, 0XFB, 0XDE, 0XBA, 0XD6, 0X79, 0XCE, 0X79, 0XCE, 0XBA, 0XD6,
0X79, 0XCE, 0XC7, 0X39, 0X41, 0X08, 0X00, 0X00, 0X00, 0X00, 0X00, 0X00, 0X86, 0X31, 0X38, 0XC6,
0X00, 0X00, 0X00, 0X00, 0XC3, 0X18, 0XCB, 0X5A, 0X86, 0X31, 0XC3, 0X18, 0XCB, 0X5A, 0X7D, 0XEF,
0XFF, 0XFF, 0X7D, 0XEF, 0XCF, 0XBB, 0XC3, 0XB0, 0X41, 0XD0, 0X41, 0XD0, 0X82, 0XB8, 0X4D, 0XB3,
0X7D, 0XE7, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XBE, 0XF7, 0XBE, 0XF7, 0X3D, 0XEF, 0XFB, 0XDE, 0XBA, 0XD6, 0X79, 0XCE, 0X79, 0XCE, 0XFA, 0XD6,
0XF7, 0XBD, 0X04, 0X21, 0X86, 0X31, 0X04, 0X21, 0X00, 0X00, 0X00, 0X00, 0X86, 0X31, 0X38, 0XC6,
0X86, 0X31, 0XC3, 0X18, 0XCB, 0X5A, 0X75, 0XAD, 0XCF, 0X7B, 0X41, 0X08, 0X86, 0X31, 0XF7, 0XBD,
0XFF, 0XFF, 0XFF, 0XFF, 0XBE, 0XEF, 0X74, 0XB5, 0X30, 0X9C, 0X30, 0X9C, 0X72, 0XA4, 0XBB, 0XD6,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XBE, 0XF7, 0X7D, 0XEF, 0X3C, 0XE7, 0XFB, 0XDE, 0XBA, 0XD6, 0X79, 0XCE, 0X79, 0XCE, 0X3C, 0XE7,
0X71, 0X8C, 0X81, 0X08, 0X0C, 0X63, 0XCF, 0X7B, 0X82, 0X10, 0X00, 0X00, 0X8A, 0X52, 0X38, 0XC6,
0X75, 0XAD, 0X71, 0X8C, 0XB6, 0XB5, 0X3C, 0XE7, 0XFB, 0XDE, 0XC7, 0X39, 0X00, 0X00, 0XCF, 0X73,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XBE, 0XF7,
0X7D, 0XEF, 0X7D, 0XEF, 0X3B, 0XDF, 0XFA, 0XD6, 0X79, 0XCE, 0X79, 0XCE, 0XFB, 0XDE, 0XB9, 0XCE,
0XC7, 0X39, 0XC4, 0X20, 0X71, 0X8C, 0XBA, 0XD6, 0X71, 0X8C, 0XCB, 0X5A, 0XB2, 0X94, 0XBA, 0XD6,
0XFF, 0XFF, 0X7D, 0XEF, 0X7D, 0XEF, 0XFF, 0XFF, 0XFF, 0XFF, 0XB6, 0XB5, 0X46, 0X29, 0X05, 0X19,
0X75, 0XA5, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XBE, 0XF7,
0X7D, 0XEF, 0X3C, 0XE7, 0XFB, 0XDE, 0XBA, 0XD6, 0X79, 0XCE, 0XBA, 0XD6, 0XFC, 0XDE, 0X4E, 0X63,
0X42, 0X08, 0X0C, 0X63, 0XF7, 0XBD, 0XBE, 0XF7, 0XFF, 0XFF, 0XFB, 0XDE, 0XFB, 0XDE, 0XBE, 0XF7,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XF4, 0X9C, 0X04, 0X21,
0X05, 0X21, 0XB6, 0XA5, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XBE, 0XF7, 0XBE, 0XF7, 0X7D, 0XEF,
0X3C, 0XE7, 0XFB, 0XDE, 0XBA, 0XD6, 0X79, 0XCE, 0XFB, 0XDE, 0XBB, 0XD6, 0XD1, 0X73, 0X83, 0X18,
0X86, 0X39, 0X34, 0X9D, 0XBD, 0XEF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XBE, 0XFF, 0X35, 0XD6, 0XEB, 0XCC, 0X43, 0XB3,
0X40, 0X51, 0X05, 0X19, 0XF5, 0X8C, 0XBE, 0XEF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XBE, 0XF7, 0XBE, 0XF7, 0X7D, 0XEF, 0X7D, 0XEF, 0X3C, 0XE7,
0XFB, 0XDE, 0XBA, 0XDE, 0XBA, 0XD6, 0X3C, 0XDF, 0X3A, 0XBE, 0X4F, 0X63, 0X82, 0X49, 0X40, 0XA3,
0X23, 0XB4, 0XCC, 0X83, 0X3A, 0XBE, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XBF, 0XF7, 0XB5, 0XBD, 0X82, 0X92, 0X20, 0XF4, 0XA0, 0XFC,
0X60, 0XE4, 0X40, 0X82, 0X84, 0X41, 0X8F, 0X6B, 0X77, 0XAD, 0X3D, 0XE7, 0XFF, 0XFF, 0XFF, 0XFF,
0XFE, 0XFF, 0XBE, 0XF7, 0XBE, 0XF7, 0XBE, 0XF7, 0X7D, 0XEF, 0X7D, 0XEF, 0X3C, 0XE7, 0XFB, 0XDE,
0XFB, 0XDE, 0X3D, 0XE7, 0XBB, 0XCE, 0X36, 0X9D, 0X0B, 0X6B, 0X41, 0X6A, 0X60, 0XC4, 0X20, 0XFE,
0X60, 0XF5, 0X00, 0X8B, 0XC7, 0X6A, 0X38, 0XC6, 0XBE, 0XF7, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0X7D, 0XEF, 0X4B, 0X7B, 0X80, 0XB2, 0XA0, 0XFC, 0XA0, 0XFC,
0XE0, 0XFC, 0XE0, 0XFC, 0XC0, 0XCB, 0XC1, 0X8A, 0X45, 0X62, 0X4D, 0X6B, 0XB3, 0X94, 0XF7, 0XBD,
0X3D, 0XDF, 0XFF, 0XF7, 0XFF, 0XFF, 0XBE, 0XF7, 0X7D, 0XEF, 0X7D, 0XEF, 0X7D, 0XE7, 0X3D, 0XDF,
0XBA, 0XC6, 0X75, 0XA5, 0X8D, 0X7B, 0X84, 0X7A, 0X40, 0XB3, 0XE0, 0XEC, 0XE0, 0XFD, 0XE0, 0XFD,
0X60, 0XF5, 0X20, 0XE5, 0XA0, 0XD4, 0X0A, 0X6B, 0XFB, 0XDE, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0X7D, 0XEF, 0XCC, 0X93, 0X40, 0XEB, 0X60, 0XFC, 0XA0, 0XFC,
0XE0, 0XFC, 0X20, 0XFD, 0X60, 0XFD, 0X20, 0XF5, 0XA0, 0XD4, 0XC0, 0XBB, 0X42, 0X9B, 0X45, 0X8B,
0X6B, 0X9C, 0XAE, 0X9C, 0X71, 0X8C, 0XB3, 0X94, 0X33, 0X9D, 0X34, 0XA5, 0XF2, 0XA4, 0XF0, 0XB4,
0XCA, 0X9B, 0X04, 0X9B, 0X40, 0XBB, 0X20, 0XE4, 0X20, 0XFD, 0XA0, 0XFD, 0XA0, 0XFD, 0XE0, 0XFD,
0XE0, 0XFD, 0XE0, 0XFD, 0X20, 0XC4, 0X88, 0X5A, 0X38, 0XBE, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0X78, 0XD6, 0X46, 0XAB, 0X40, 0XDB, 0X20, 0XF4,
0X60, 0XFC, 0XA0, 0XFC, 0XE0, 0XFC, 0X60, 0XFD, 0XA0, 0XFD, 0X60, 0XFD, 0X20, 0XF5, 0XA0, 0XDC,
0XC0, 0XB3, 0XC0, 0X51, 0X86, 0X29, 0X0D, 0X63, 0X8F, 0X7B, 0X0D, 0X5B, 0XC7, 0X41, 0X01, 0X82,
0X00, 0XC3, 0XC0, 0XE3, 0X60, 0XFC, 0XA0, 0XFC, 0XE0, 0XFC, 0XE0, 0XFC, 0X60, 0XF5, 0X60, 0XF5,
0X20, 0XE5, 0X80, 0X9B, 0X86, 0X62, 0X30, 0X84, 0X79, 0XCE, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0X38, 0XC6, 0X2D, 0X9C, 0X05, 0X93,
0X43, 0XA3, 0X82, 0XB3, 0XC2, 0XBB, 0XC2, 0XBB, 0X22, 0XB4, 0X82, 0XA3, 0X42, 0X93, 0XC3, 0X7A,
0X85, 0X62, 0X0B, 0X63, 0X71, 0X84, 0XB6, 0XB5, 0X79, 0XCE, 0X79, 0XC6, 0XB5, 0XAD, 0X70, 0X94,
0X4A, 0X8B, 0X06, 0X83, 0X04, 0X93, 0X04, 0X9B, 0X43, 0X9B, 0X43, 0X9B, 0X43, 0X93, 0X04, 0X83,
0X08, 0X73, 0X8D, 0X73, 0XB3, 0X94, 0X79, 0XCE, 0X7D, 0XEF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0X3C, 0XDF, 0X38, 0XBE,
0X75, 0XB5, 0X33, 0XA5, 0X33, 0XA5, 0XF3, 0X9C, 0XF3, 0X9C, 0XF3, 0X9C, 0XF3, 0X94, 0XF3, 0X9C,
0X35, 0XA5, 0XF8, 0XBD, 0XFB, 0XDE, 0XBE, 0XF7, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0X7E, 0XEF,
0XBB, 0XD6, 0XF8, 0XBD, 0XB6, 0XAD, 0X75, 0XAD, 0X34, 0XA5, 0X33, 0X9D, 0X34, 0X9D, 0X35, 0XA5,
0XB7, 0XAD, 0X79, 0XC6, 0X3C, 0XE7, 0XBE, 0XF7, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
};
const unsigned char PROGMEM icon_40x40[3200] = { /* 0X00,0X10,0X28,0X00,0X28,0X00,0X01,0X1B, */
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0X5D, 0XEF, 0X71, 0X8C, 0X31, 0X84, 0X31, 0X84,
0X93, 0XC5, 0X92, 0XCD, 0X91, 0XCD, 0X91, 0XD5, 0X91, 0XD5, 0X91, 0XCD, 0X72, 0XCD, 0X72, 0XC5,
0X56, 0XDE, 0XBE, 0XFF, 0XDB, 0XDE, 0XFB, 0XDE, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XCE, 0X7B, 0X00, 0X00, 0X00, 0X00, 0X00, 0X00,
0X00, 0X5A, 0X20, 0XDD, 0X20, 0XDD, 0X20, 0XDD, 0X20, 0XDD, 0X20, 0XDD, 0XE0, 0XD4, 0XA0, 0XD4,
0X61, 0XA3, 0XA7, 0X39, 0XE5, 0X18, 0X05, 0X21, 0X92, 0X94, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XF9, 0XEE, 0XEB, 0X9B, 0XA1, 0X18, 0X23, 0X73, 0X81, 0XC5, 0X21, 0X9C,
0X61, 0X39, 0X81, 0XEE, 0X40, 0XFF, 0XE0, 0XFE, 0XE0, 0XFE, 0XE0, 0XFE, 0X40, 0XFF, 0XC0, 0XF6,
0XC0, 0X49, 0XA0, 0X18, 0X00, 0X42, 0X60, 0X18, 0X00, 0X00, 0X74, 0XB5, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0X93, 0XCD, 0XC3, 0XBB, 0XA0, 0X51, 0XE1, 0X39, 0XC2, 0XFF, 0XE0, 0XFF, 0XE0, 0XFF,
0X63, 0XBD, 0X61, 0XE6, 0X40, 0XFF, 0XE0, 0XFE, 0XE0, 0XFE, 0XC0, 0XFE, 0X60, 0XFF, 0X21, 0X73,
0XE1, 0X28, 0X81, 0XEE, 0X61, 0XFF, 0X21, 0XEE, 0XA0, 0X41, 0X20, 0X08, 0X90, 0XCD, 0XDE, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0X5C, 0XF7,
0X0B, 0XAC, 0XC0, 0XB3, 0XA1, 0XEE, 0XC3, 0X5A, 0X22, 0X8C, 0XE1, 0XFF, 0X40, 0XFF, 0X40, 0XFF,
0XC0, 0XFF, 0X80, 0XFF, 0X20, 0XFF, 0X20, 0XFF, 0X20, 0XFF, 0X00, 0XFF, 0X20, 0XFF, 0XA1, 0XAC,
0X21, 0XC5, 0X20, 0XFF, 0X60, 0XFE, 0X00, 0XFF, 0X02, 0XDE, 0XE0, 0X20, 0X40, 0X82, 0X49, 0XBC,
0X3B, 0XEF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0X5C, 0XF7, 0X67, 0X9B,
0XE0, 0XB3, 0X81, 0XFF, 0XC3, 0XFF, 0X83, 0X9C, 0X82, 0XDE, 0XC0, 0XFF, 0X60, 0XFF, 0X60, 0XFF,
0X40, 0XFF, 0X60, 0XFF, 0X40, 0XFF, 0X40, 0XFF, 0X40, 0XFF, 0X20, 0XFF, 0X00, 0XFF, 0X60, 0XFF,
0X40, 0XFF, 0XA0, 0XFE, 0X80, 0XFE, 0X40, 0XFE, 0XE0, 0XFE, 0XA2, 0XB4, 0X41, 0XBC, 0X20, 0XCC,
0X87, 0XA3, 0XB8, 0XE6, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0X9D, 0XF7, 0XA8, 0XA3, 0X60, 0XBC,
0XA2, 0XFF, 0XA5, 0XFF, 0X44, 0XFF, 0XA1, 0XFF, 0XA0, 0XFF, 0X60, 0XFF, 0X80, 0XFF, 0X80, 0XFF,
0X80, 0XFF, 0X80, 0XFF, 0X60, 0XFF, 0X60, 0XFF, 0X40, 0XFF, 0X40, 0XFF, 0X20, 0XFF, 0X20, 0XFF,
0X00, 0XFF, 0XC0, 0XFE, 0XA0, 0XFE, 0X80, 0XFE, 0X40, 0XFE, 0X60, 0XFE, 0X20, 0XFE, 0X40, 0XFE,
0XE0, 0XCB, 0XE3, 0X92, 0X7C, 0XF7, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0X4C, 0XAC, 0XC0, 0XB3, 0XA4, 0XFF,
0XA6, 0XFF, 0X45, 0XFF, 0X62, 0XFF, 0X80, 0XFF, 0X80, 0XFF, 0X80, 0XFF, 0XA0, 0XFF, 0XA0, 0XFF,
0XA0, 0XFF, 0XA0, 0XFF, 0X80, 0XFF, 0X80, 0XFF, 0X80, 0XFF, 0X60, 0XFF, 0X40, 0XFF, 0X40, 0XFF,
0X20, 0XFF, 0XE0, 0XFE, 0XC0, 0XFE, 0X80, 0XFE, 0X60, 0XFE, 0X40, 0XFE, 0X20, 0XFE, 0X00, 0XFE,
0XE0, 0XFD, 0XE0, 0XC3, 0X2A, 0XAC, 0X7D, 0XF7, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XD4, 0XD5, 0X40, 0XAB, 0X43, 0XFF, 0XA8, 0XFF,
0X67, 0XFF, 0X62, 0XFF, 0X80, 0XFF, 0X80, 0XFF, 0XA0, 0XFF, 0XA0, 0XFF, 0XC0, 0XFF, 0XC0, 0XFF,
0XC0, 0XFF, 0XA0, 0XFF, 0XA0, 0XFF, 0XA0, 0XFF, 0X80, 0XFF, 0X80, 0XFF, 0X60, 0XFF, 0X40, 0XFF,
0X40, 0XFF, 0X00, 0XFF, 0XE0, 0XFE, 0XA0, 0XFE, 0X80, 0XFE, 0X40, 0XFE, 0X20, 0XFE, 0XE0, 0XFD,
0XE0, 0XFD, 0XC0, 0XFD, 0XA0, 0XA2, 0X11, 0XBD, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XDA, 0XE6, 0XE4, 0X9A, 0XE1, 0XE5, 0XE8, 0XFF, 0X69, 0XFF,
0X65, 0XFF, 0X60, 0XFF, 0X80, 0XFF, 0XA0, 0XFF, 0XC0, 0XFF, 0XE0, 0XFF, 0XE0, 0XFF, 0XE0, 0XFF,
0XE0, 0XFF, 0XC0, 0XFF, 0XC0, 0XFF, 0XA0, 0XFF, 0XA0, 0XFF, 0X80, 0XFF, 0X80, 0XFF, 0X60, 0XFF,
0X40, 0XFF, 0X00, 0XFF, 0X00, 0XFF, 0X20, 0XFF, 0XE0, 0XFE, 0X60, 0XFE, 0X20, 0XFE, 0X00, 0XFE,
0XC0, 0XFD, 0XE0, 0XFD, 0XE0, 0XE4, 0X85, 0XAB, 0XFA, 0XE6, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0X2B, 0XB4, 0XC0, 0XB3, 0XC8, 0XFF, 0X8C, 0XFF, 0X68, 0XFF,
0X61, 0XFF, 0XA0, 0XFF, 0XA0, 0XFF, 0XC0, 0XFF, 0XE0, 0XFF, 0XE1, 0XFF, 0XA1, 0XDE, 0X61, 0XEF,
0XE1, 0XFF, 0XE0, 0XFF, 0XE0, 0XFF, 0XC0, 0XFF, 0XC0, 0XFF, 0XA0, 0XFF, 0X80, 0XFF, 0X60, 0XFF,
0X40, 0XFF, 0X60, 0XFF, 0XC0, 0XFF, 0X61, 0XDE, 0X00, 0XE6, 0X80, 0XFE, 0X40, 0XFE, 0X00, 0XFE,
0XE0, 0XFD, 0XC0, 0XFD, 0XE0, 0XFD, 0XC0, 0XC3, 0XE9, 0XAB, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0X5D, 0XEF, 0XA3, 0XAB, 0XA3, 0XF6, 0XCC, 0XFF, 0X4C, 0XFF, 0X64, 0XFF,
0X80, 0XFF, 0XA0, 0XFF, 0XC0, 0XFF, 0XE0, 0XFF, 0X61, 0XEF, 0X22, 0X6B, 0X82, 0X5A, 0X82, 0XB5,
0XE2, 0XFF, 0XE1, 0XFF, 0XE0, 0XFF, 0XE0, 0XFF, 0XE0, 0XFF, 0XA0, 0XFF, 0X80, 0XFF, 0X60, 0XFF,
0XA0, 0XFF, 0XE1, 0XFF, 0X42, 0X8C, 0XC1, 0X41, 0X21, 0XA4, 0XA0, 0XFE, 0X80, 0XFE, 0X20, 0XFE,
0XE0, 0XFD, 0XC0, 0XFD, 0XA0, 0XFD, 0X20, 0XF5, 0XC0, 0X9A, 0X35, 0XD6, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0X51, 0XC5, 0X60, 0XBC, 0XC9, 0XFF, 0X8E, 0XFF, 0X6A, 0XFF, 0X61, 0XFF,
0X80, 0XFF, 0XA0, 0XFF, 0XC0, 0XFF, 0XE1, 0XFF, 0XE1, 0X62, 0X80, 0X10, 0X05, 0XE7, 0XA4, 0XF7,
0XE4, 0XFF, 0XE3, 0XFF, 0XE2, 0XFF, 0XE0, 0XFF, 0XE0, 0XFF, 0XC0, 0XFF, 0XA0, 0XFF, 0XA0, 0XFF,
0XC1, 0XFF, 0XE2, 0X83, 0X40, 0X08, 0X22, 0XCE, 0X60, 0XF7, 0XA0, 0XFE, 0X60, 0XFE, 0X20, 0XFE,
0XE0, 0XFD, 0XC0, 0XFD, 0X80, 0XFD, 0XA0, 0XFD, 0XA0, 0XC3, 0XAC, 0XBC, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XDE, 0XFF, 0XA7, 0XAB, 0X81, 0XDD, 0XED, 0XFF, 0XB0, 0XFF, 0X69, 0XFF, 0X60, 0XFF,
0X80, 0XFF, 0XA0, 0XFF, 0XE0, 0XFF, 0X61, 0XD6, 0X22, 0X29, 0XA6, 0X31, 0XE3, 0X7B, 0X46, 0XEF,
0XE6, 0XFF, 0XE4, 0XFF, 0XE2, 0XFF, 0XE1, 0XFF, 0XE0, 0XFF, 0XC0, 0XFF, 0XA0, 0XFF, 0XE0, 0XFF,
0X81, 0XD6, 0XA0, 0X18, 0XC4, 0X18, 0XA1, 0X62, 0XC1, 0XCD, 0X40, 0XFF, 0X60, 0XFE, 0X20, 0XFE,
0XE0, 0XFD, 0XC0, 0XFD, 0X80, 0XFD, 0X80, 0XFD, 0XA0, 0XEC, 0X48, 0XBC, 0XDF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XF9, 0XE6, 0XE3, 0X9A, 0X67, 0XEE, 0XD1, 0XFF, 0XB0, 0XFF, 0X86, 0XFF, 0X60, 0XFF,
0X80, 0XFF, 0XA0, 0XFF, 0XE0, 0XFF, 0X60, 0X94, 0X91, 0X73, 0XD9, 0XBD, 0X00, 0X00, 0X05, 0X84,
0XE8, 0XFF, 0XE5, 0XFF, 0XE3, 0XFF, 0XE1, 0XFF, 0XE0, 0XFF, 0XC0, 0XFF, 0XA0, 0XFF, 0XE0, 0XFF,
0X20, 0XAD, 0XE9, 0X41, 0XB7, 0XB5, 0X01, 0X00, 0X60, 0X62, 0X21, 0XFF, 0X80, 0XFE, 0X20, 0XFE,
0XE0, 0XFD, 0XC0, 0XFD, 0X80, 0XFD, 0X60, 0XFD, 0X20, 0XF5, 0XE3, 0XBB, 0XD9, 0XE6, 0XFF, 0XFF,
0XFF, 0XFF, 0XD3, 0XCD, 0X40, 0XA3, 0X2B, 0XF7, 0XD3, 0XFF, 0XB0, 0XFF, 0X63, 0XFF, 0X60, 0XFF,
0X80, 0XFF, 0XA0, 0XFF, 0XE0, 0XFF, 0XA0, 0X9C, 0X30, 0X6B, 0X97, 0XB5, 0X00, 0X00, 0X83, 0X52,
0XC6, 0XFF, 0XE5, 0XFF, 0XE3, 0XFF, 0XE1, 0XFF, 0XE0, 0XFF, 0XC0, 0XFF, 0XA0, 0XFF, 0XE0, 0XFF,
0X20, 0XAD, 0XEA, 0X41, 0X77, 0XAD, 0X01, 0X00, 0XC0, 0X49, 0XE0, 0XF6, 0XA0, 0XFE, 0X20, 0XFE,
0XE0, 0XFD, 0XC0, 0XFD, 0X80, 0XFD, 0X60, 0XFD, 0X40, 0XFD, 0XA0, 0XBB, 0XD3, 0XCD, 0XFF, 0XFF,
0XFF, 0XFF, 0X50, 0XCD, 0X00, 0XB4, 0X8E, 0XFF, 0XF4, 0XFF, 0XB0, 0XFF, 0X42, 0XFF, 0X60, 0XFF,
0X80, 0XFF, 0XA0, 0XFF, 0XE0, 0XFF, 0XA1, 0XDE, 0X01, 0X21, 0X00, 0X00, 0X00, 0X00, 0X25, 0X8C,
0XE5, 0XFF, 0XE3, 0XFF, 0XE2, 0XFF, 0XE0, 0XFF, 0XE0, 0XFF, 0XC0, 0XFF, 0XA0, 0XFF, 0XE0, 0XFF,
0XE1, 0XDE, 0X01, 0X21, 0X00, 0X00, 0X00, 0X00, 0X61, 0X5A, 0X20, 0XFF, 0X80, 0XFE, 0X20, 0XFE,
0X00, 0XFE, 0XE0, 0XFD, 0XA0, 0XFD, 0X60, 0XFD, 0X60, 0XFD, 0XC0, 0XCB, 0X71, 0XCD, 0XFF, 0XFF,
0XFF, 0XFF, 0X50, 0XCD, 0X40, 0XC4, 0XB0, 0XFF, 0XF5, 0XFF, 0X8F, 0XFF, 0X41, 0XFF, 0X80, 0XFF,
0XA0, 0XFF, 0XC0, 0XFF, 0XE0, 0XFF, 0XE1, 0XFF, 0X21, 0X8C, 0X60, 0X10, 0X43, 0X6B, 0X44, 0XEF,
0XE2, 0XFF, 0XE2, 0XFF, 0XE1, 0XFF, 0XE0, 0XFF, 0XC0, 0XFF, 0XA0, 0XFF, 0X80, 0XFF, 0X80, 0XFF,
0XE1, 0XFF, 0XC1, 0XA4, 0XC2, 0X18, 0XA2, 0X39, 0XA1, 0XCD, 0X20, 0XFF, 0X60, 0XFE, 0X20, 0XFE,
0XC0, 0XFD, 0X80, 0XFD, 0X80, 0XFD, 0X60, 0XFD, 0X60, 0XFD, 0XE0, 0XCB, 0X91, 0XCD, 0XFF, 0XFF,
0XFF, 0XFF, 0X50, 0XCD, 0X40, 0XC4, 0XD2, 0XFF, 0XF7, 0XFF, 0XAF, 0XFF, 0X01, 0XFF, 0X00, 0XFF,
0X00, 0XFF, 0X40, 0XFF, 0XA0, 0XFF, 0XE0, 0XFF, 0XA1, 0XFF, 0X82, 0XD6, 0XC2, 0XFF, 0XE0, 0XFF,
0XE0, 0XFF, 0XE0, 0XFF, 0XE0, 0XFF, 0XC0, 0XFF, 0XC0, 0XFF, 0XA0, 0XFF, 0X80, 0XFF, 0X60, 0XFF,
0X60, 0XFF, 0XC1, 0XFF, 0X82, 0XDE, 0XC2, 0XEE, 0X61, 0XFF, 0X80, 0XFE, 0XC0, 0XFD, 0X20, 0XFD,
0XA1, 0XFC, 0X61, 0XFC, 0X61, 0XFC, 0XC0, 0XFC, 0X60, 0XFD, 0XE0, 0XCB, 0X51, 0XC5, 0XFF, 0XFF,
0XFF, 0XFF, 0X50, 0XCD, 0X60, 0XC4, 0XD4, 0XFF, 0XF9, 0XFF, 0X2D, 0XFF, 0X00, 0XFE, 0XC0, 0XFD,
0XA1, 0XFD, 0X21, 0XFE, 0XE0, 0XFE, 0XC0, 0XFF, 0XE0, 0XFF, 0XE0, 0XFF, 0XE0, 0XFF, 0XE0, 0XFF,
0XE0, 0XFF, 0XE0, 0XFF, 0XC0, 0XFF, 0XC0, 0XFF, 0XA0, 0XFF, 0X80, 0XFF, 0X80, 0XFF, 0X60, 0XFF,
0X40, 0XFF, 0X40, 0XFF, 0X80, 0XFF, 0X20, 0XFF, 0XA0, 0XFE, 0X20, 0XFE, 0X01, 0XFD, 0X01, 0XFC,
0X62, 0XFB, 0X42, 0XFB, 0X82, 0XFB, 0X21, 0XFC, 0X20, 0XFD, 0X00, 0XD4, 0X71, 0XC5, 0XFF, 0XFF,
0XFF, 0XFF, 0X50, 0XCD, 0X20, 0XC4, 0XD4, 0XFF, 0XBA, 0XFF, 0X2E, 0XFE, 0XE1, 0XFC, 0X61, 0XFC,
0X61, 0XFC, 0X01, 0XFD, 0X01, 0XFE, 0X20, 0XFF, 0XA0, 0XFF, 0XA0, 0XFF, 0XC0, 0XFF, 0XC0, 0XFF,
0XC0, 0XFF, 0XC0, 0XFF, 0XA0, 0XFF, 0XA0, 0XFF, 0X80, 0XFF, 0X80, 0XFF, 0X60, 0XFF, 0X40, 0XFF,
0X40, 0XFF, 0X00, 0XFF, 0XC0, 0XFE, 0XA0, 0XFE, 0X80, 0XFE, 0X80, 0XFD, 0X61, 0XFC, 0X62, 0XFB,
0XA3, 0XFA, 0XA3, 0XFA, 0X42, 0XFB, 0X01, 0XFC, 0XE0, 0XFC, 0XE0, 0XCB, 0X71, 0XCD, 0XFF, 0XFF,
0XFF, 0XFF, 0X50, 0XCD, 0XC0, 0XB3, 0XB3, 0XFF, 0X7A, 0XFF, 0X91, 0XFD, 0X03, 0XFC, 0X02, 0XFB,
0X22, 0XFB, 0X62, 0XFC, 0X81, 0XFD, 0XC0, 0XFE, 0XA0, 0XFF, 0XA0, 0XFF, 0XA0, 0XFF, 0XA0, 0XFF,
0XA0, 0XFF, 0XA0, 0XFF, 0X80, 0XFF, 0X80, 0XFF, 0X60, 0XFF, 0X60, 0XFF, 0X40, 0XFF, 0X40, 0XFF,
0X20, 0XFF, 0XE0, 0XFE, 0XC0, 0XFE, 0XA0, 0XFE, 0X60, 0XFE, 0X60, 0XFD, 0X41, 0XFC, 0X62, 0XFB,
0XC3, 0XFA, 0XA3, 0XFA, 0X42, 0XFB, 0X01, 0XFC, 0X20, 0XFD, 0XC0, 0XCB, 0X91, 0XCD, 0XFF, 0XFF,
0XFF, 0XFF, 0X14, 0XD6, 0X20, 0XAB, 0X51, 0XF7, 0XBE, 0XFF, 0X17, 0XFE, 0X65, 0XFC, 0X61, 0XFB,
0XA2, 0XFB, 0XA1, 0XFC, 0XC1, 0XFD, 0X00, 0XFF, 0X80, 0XFF, 0X80, 0XFF, 0X80, 0XFF, 0X80, 0XFF,
0X80, 0XFF, 0X80, 0XFF, 0X80, 0XFF, 0X60, 0XFF, 0X60, 0XFF, 0X60, 0XFF, 0X40, 0XFF, 0X20, 0XFF,
0X00, 0XFF, 0XC0, 0XFE, 0XA0, 0XFE, 0X80, 0XFE, 0X60, 0XFE, 0XC0, 0XFD, 0XC0, 0XFC, 0X41, 0XFC,
0XC1, 0XFB, 0XA2, 0XFB, 0X01, 0XFC, 0XA0, 0XFC, 0X40, 0XFD, 0XA0, 0XC3, 0XF4, 0XD5, 0XFF, 0XFF,
0XFF, 0XFF, 0X5B, 0XEF, 0X24, 0X9B, 0X49, 0XE6, 0XB8, 0XFF, 0X92, 0XFE, 0X25, 0XFD, 0XA0, 0XFC,
0X02, 0XFD, 0XE1, 0XFD, 0XE0, 0XFE, 0X40, 0XFF, 0X60, 0XFF, 0X40, 0XFF, 0X60, 0XFF, 0X60, 0XFF,
0X60, 0XFF, 0X60, 0XFF, 0X40, 0XFF, 0X40, 0XFF, 0X40, 0XFF, 0X40, 0XFF, 0X20, 0XFF, 0X00, 0XFF,
0XC0, 0XFE, 0XA0, 0XFE, 0X80, 0XFE, 0X40, 0XFE, 0X40, 0XFE, 0X00, 0XFE, 0X80, 0XFD, 0X01, 0XF5,
0X41, 0XFD, 0X01, 0XFD, 0XC0, 0XFC, 0X40, 0XFD, 0X00, 0XF5, 0XC4, 0XBB, 0XFA, 0XE6, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0X2A, 0XB4, 0XA0, 0XD4, 0XA2, 0XFE, 0X20, 0XFE, 0XE0, 0XFD, 0X00, 0XFE,
0X80, 0XFE, 0X21, 0XEE, 0X41, 0XE6, 0X40, 0XFF, 0X40, 0XFF, 0X40, 0XFF, 0X40, 0XFF, 0X40, 0XFF,
0X40, 0XFF, 0X40, 0XFF, 0X40, 0XFF, 0X20, 0XFF, 0X20, 0XFF, 0X00, 0XFF, 0XE0, 0XFE, 0XC0, 0XFE,
0XA0, 0XFE, 0X80, 0XFE, 0X60, 0XFE, 0X40, 0XFE, 0X00, 0XFE, 0X00, 0XFE, 0X00, 0XFE, 0X40, 0XCC,
0XE1, 0XAB, 0XC1, 0XED, 0X80, 0XFD, 0X60, 0XFD, 0X60, 0XE4, 0X29, 0XB4, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0X15, 0XD6, 0XE0, 0XBB, 0X60, 0XFE, 0XC8, 0XFE, 0XC8, 0XFE, 0X02, 0XFF,
0X60, 0XDD, 0X40, 0XA3, 0XA1, 0XDD, 0X40, 0XFF, 0X20, 0XFF, 0X20, 0XFF, 0X20, 0XFF, 0X20, 0XFF,
0X20, 0XFF, 0X20, 0XFF, 0X20, 0XFF, 0X00, 0XFF, 0XE0, 0XFE, 0XC0, 0XFE, 0XC0, 0XFE, 0XA0, 0XFE,
0X80, 0XFE, 0X60, 0XFE, 0X40, 0XFE, 0X20, 0XFE, 0X20, 0XFE, 0X20, 0XFE, 0X20, 0XFE, 0X40, 0XED,
0XC0, 0X9A, 0X40, 0XA3, 0X80, 0XF5, 0X60, 0XFD, 0X60, 0XBB, 0XEE, 0XBC, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XDF, 0XFF, 0X63, 0XAB, 0X42, 0XE5, 0XB4, 0XFF, 0X97, 0XFF, 0XAA, 0XF6,
0X80, 0XAB, 0XA0, 0X92, 0XA1, 0XDD, 0X41, 0XFF, 0X40, 0XFF, 0X60, 0XFF, 0X60, 0XFF, 0X60, 0XFF,
0X60, 0XFF, 0X40, 0XFF, 0X40, 0XFF, 0X40, 0XFF, 0X20, 0XFF, 0X20, 0XFF, 0X00, 0XFF, 0XE0, 0XFE,
0XC0, 0XFE, 0X80, 0XFE, 0X61, 0XFE, 0X00, 0XFE, 0XA0, 0XED, 0X20, 0XE5, 0X21, 0XCC, 0X80, 0XB3,
0X00, 0XBC, 0XE0, 0XC3, 0X40, 0XED, 0XC0, 0XEC, 0X60, 0X92, 0X97, 0XE6, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0X0F, 0XC5, 0X00, 0XA3, 0XAA, 0XF6, 0X93, 0XFF, 0X2D, 0XEE,
0X63, 0XDD, 0X80, 0XD5, 0X42, 0XB4, 0X82, 0XCC, 0X00, 0XCD, 0X40, 0XD5, 0XA0, 0XDD, 0XE1, 0XE5,
0XC1, 0XE5, 0XC1, 0XE5, 0XC1, 0XE5, 0XC1, 0XE5, 0X80, 0XDD, 0X60, 0XDD, 0X20, 0XD5, 0XC0, 0XCC,
0XA0, 0XCC, 0X61, 0XC4, 0X21, 0XC4, 0X01, 0XBC, 0X01, 0XBC, 0XE0, 0XBB, 0XC0, 0XBB, 0X60, 0XD4,
0X80, 0XFD, 0X40, 0XFD, 0X80, 0XFD, 0X80, 0XBB, 0X2B, 0XAC, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0X9D, 0XF7, 0X87, 0XA3, 0X60, 0XD4, 0X0A, 0XFF, 0XCF, 0XFE,
0XC9, 0XFE, 0XC0, 0XFE, 0XC0, 0XF6, 0X40, 0XE6, 0X41, 0XCD, 0X42, 0XB4, 0XC1, 0XAB, 0X60, 0XA3,
0X60, 0XA3, 0X80, 0XA3, 0X80, 0XA3, 0X80, 0XA3, 0XA0, 0XAB, 0XC1, 0XAB, 0XE1, 0XB3, 0X22, 0XB4,
0X82, 0XC4, 0XC0, 0XCC, 0X00, 0XD5, 0X60, 0XE5, 0X81, 0XED, 0X80, 0XF5, 0X80, 0XFD, 0X80, 0XFD,
0X40, 0XFD, 0X80, 0XFD, 0X80, 0XE4, 0X85, 0XAB, 0X5C, 0XEF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFA, 0XE6, 0X23, 0XA3, 0XE0, 0XE4, 0XE8, 0XFE,
0X6A, 0XFE, 0X05, 0XFE, 0X40, 0XFE, 0XA0, 0XFE, 0XC0, 0XFE, 0XE1, 0XFE, 0XA0, 0XF6, 0XA0, 0XF6,
0XA0, 0XF6, 0XA0, 0XF6, 0X80, 0XF6, 0X80, 0XF6, 0X80, 0XF6, 0X60, 0XF6, 0X61, 0XFE, 0X81, 0XFE,
0X61, 0XFE, 0X20, 0XFE, 0X00, 0XFE, 0XC0, 0XFD, 0X80, 0XFD, 0X60, 0XFD, 0X20, 0XFD, 0X20, 0XFD,
0X60, 0XFD, 0X20, 0XF5, 0XA0, 0XA2, 0XB4, 0XCD, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0X52, 0XC5, 0XE0, 0XA2, 0XA1, 0XF5,
0X86, 0XFE, 0X06, 0XFE, 0XE2, 0XFD, 0XE0, 0XFD, 0X00, 0XFE, 0X20, 0XFE, 0X20, 0XFE, 0X20, 0XFE,
0X40, 0XFE, 0X20, 0XFE, 0X20, 0XFE, 0X20, 0XFE, 0X00, 0XFE, 0XE0, 0XFD, 0XE0, 0XFD, 0XC0, 0XFD,
0XA0, 0XFD, 0X80, 0XFD, 0X60, 0XFD, 0X40, 0XFD, 0X20, 0XFD, 0X20, 0XFD, 0X20, 0XFD, 0X40, 0XFD,
0X60, 0XFD, 0X60, 0XBB, 0X6C, 0XB4, 0XDE, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0X92, 0XCD, 0XC0, 0XA2,
0X20, 0XED, 0X22, 0XFE, 0XC1, 0XFD, 0XA0, 0XFD, 0XC0, 0XFD, 0XE0, 0XFD, 0XE0, 0XFD, 0XE0, 0XFD,
0XE0, 0XFD, 0XE0, 0XFD, 0XC0, 0XFD, 0XC0, 0XFD, 0XC0, 0XFD, 0XC0, 0XFD, 0XA0, 0XFD, 0X80, 0XFD,
0X80, 0XFD, 0X60, 0XFD, 0X40, 0XFD, 0X20, 0XFD, 0X20, 0XFD, 0X20, 0XFD, 0X60, 0XFD, 0X40, 0XFD,
0X20, 0XB3, 0XEA, 0XA3, 0X9D, 0XF7, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0X8E, 0XBC,
0XE1, 0XA2, 0X00, 0XE5, 0XE0, 0XFD, 0XC0, 0XFD, 0XA0, 0XFD, 0XA0, 0XFD, 0XA0, 0XFD, 0XA0, 0XFD,
0XC0, 0XFD, 0XA0, 0XFD, 0XA0, 0XFD, 0XA0, 0XFD, 0XA0, 0XFD, 0X80, 0XFD, 0X80, 0XFD, 0X60, 0XFD,
0X40, 0XFD, 0X20, 0XFD, 0X20, 0XFD, 0X20, 0XFD, 0X20, 0XFD, 0X80, 0XFD, 0X00, 0XF5, 0X40, 0XBB,
0X2B, 0XAC, 0X9D, 0XF7, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0X35, 0XD6, 0XE2, 0X9A, 0XA0, 0XC3, 0XA0, 0XFD, 0XE0, 0XFD, 0X80, 0XFD, 0X60, 0XFD, 0X80, 0XFD,
0X80, 0XFD, 0X60, 0XFD, 0X60, 0XFD, 0X60, 0XFD, 0X60, 0XFD, 0X60, 0XFD, 0X40, 0XFD, 0X40, 0XFD,
0X20, 0XFD, 0X20, 0XFD, 0X40, 0XFD, 0X60, 0XFD, 0X60, 0XFD, 0X00, 0XD4, 0XC1, 0X9A, 0X10, 0XC5,
0XDE, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0X98, 0XDE, 0X2B, 0XAC, 0X40, 0XB3, 0X00, 0XD4, 0X40, 0XFD, 0X80, 0XFD, 0X80, 0XFD,
0X60, 0XFD, 0X40, 0XFD, 0X40, 0XFD, 0X40, 0XFD, 0X40, 0XFD, 0X40, 0XFD, 0X40, 0XFD, 0X40, 0XFD,
0X40, 0XFD, 0X60, 0XFD, 0X40, 0XFD, 0X40, 0XDC, 0X80, 0XBB, 0XE8, 0XAB, 0X57, 0XDE, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XDF, 0XFF, 0X37, 0XD6, 0X86, 0XA3, 0XC0, 0X9A, 0XE0, 0XCB, 0X80, 0XEC,
0XE0, 0XF4, 0X20, 0XFD, 0X20, 0XFD, 0X20, 0XFD, 0X20, 0XFD, 0X20, 0XFD, 0X20, 0XFD, 0X00, 0XF5,
0XA0, 0XEC, 0X00, 0XD4, 0X40, 0XB3, 0X03, 0X9B, 0X92, 0XC5, 0XBD, 0XF7, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XBE, 0XF7, 0XF5, 0XCD, 0XAD, 0XBC, 0X69, 0XBC,
0X05, 0XBC, 0X03, 0XC4, 0X01, 0XC4, 0X01, 0XC4, 0X01, 0XC4, 0X01, 0XC4, 0XE2, 0XC3, 0X24, 0XC4,
0X68, 0XBC, 0XAC, 0XBC, 0XD3, 0XCD, 0X9E, 0XF7, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0X5B, 0XEF, 0X98, 0XDE, 0X56, 0XD6, 0X57, 0XD6, 0X57, 0XD6, 0X56, 0XD6, 0X77, 0XDE, 0X1B, 0XEF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
};
libraries/MCUFRIEND_kbv/examples/readpixel_kbv/readpixel_kbv.ino
+135
View File
@@ -0,0 +1,135 @@
#define LCD_CS A3 // Chip Select goes to Analog 3
#define LCD_CD A2 // Command/Data goes to Analog 2
#define LCD_WR A1 // LCD Write goes to Analog 1
#define LCD_RD A0 // LCD Read goes to Analog 0
#define LCD_RESET A4 // Can alternately just connect to Arduino's reset pin
#include <Adafruit_GFX.h> // Hardware-specific library
#include <MCUFRIEND_kbv.h>
MCUFRIEND_kbv tft;
//#include <Adafruit_TFTLCD.h> // Hardware-specific library
//Adafruit_TFTLCD tft(LCD_CS, LCD_CD, LCD_WR, LCD_RD, LCD_RESET);
//Adafruit_TFTLCD tft;
// Assign human-readable names to some common 16-bit color values:
#define BLACK 0x0000
#define BLUE 0x001F
#define RED 0xF800
#define GREEN 0x07E0
#define CYAN 0x07FF
#define MAGENTA 0xF81F
#define YELLOW 0xFFE0
#define WHITE 0xFFFF
void setup(void);
void loop(void);
uint16_t g_identifier;
void setup(void) {
tft.reset();
g_identifier = tft.readID();
Serial.begin(9600);
Serial.print("readID = 0x");
Serial.println(g_identifier, HEX);
if (g_identifier == 0xFFFF) g_identifier = 0x9341;
if (g_identifier == 0) {
Serial.println("Unknown ID");
while (1);
}
tft.begin(g_identifier);
tft.setRotation(0);
}
uint16_t colors[] = {
BLACK, BLUE
};
void colordump(uint16_t x, uint16_t y)
{
uint16_t pixel, pixels[32];
char i, j, buf[20], dirty;
uint8_t wid = (tft.width() - 9 * 6)/ (5 * 6), ht = (tft.height() / 8) - 1;
tft.setTextColor(WHITE);
tft.setTextSize(1);
for (j = 0; j < ht; j++) {
sprintf(buf, "%3d,%3d:", x, y + j);
tft.print(buf);
dirty = 1;
for (i = 0; i < wid; i++) {
#if 1 && defined(MCUFRIEND_KBV_H_)
if (dirty) tft.readGRAM(x, y + j, pixels, wid, 1);
dirty = 0;
pixel = pixels[i];
#else
pixel = tft.readPixel(x + i, y + j);
#endif
tft.print(" ");
if (pixel == WHITE) tft.setTextColor(GREEN);
sprintf(buf, "%04X", pixel);
tft.print(buf);
tft.setTextColor(WHITE);
}
tft.println();
}
}
uint16_t bgr(uint16_t color)
{
return ((color & 0xF800) >> 11) | (color & 0x7E0) | (color & 0x1F) << 11;
}
void duffcolor(uint16_t color)
{
uint16_t pixel, x, y;
char done, buf[20];
uint16_t BGR = bgr(color);
for (done = 0, y = 0; y < 320 && !done; y++) {
for (x= 0; x < 240; x++) {
// pixel = readxy(x, y);
pixel = tft.readPixel(x, y);
if (pixel != BGR) {
done = 1;
sprintf(buf, "0x%04X @ %d, %d", pixel, x, y);
tft.println(buf);
break;
}
}
}
}
uint8_t aspect;
char *aspectname[] = {
"PORTRAIT", "LANDSCAPE", "PORTRAIT_REV", "LANDSCAPE_REV"
};
void loop(void)
{
uint16_t iter, color;
char buf[80];
aspect = (aspect + 1) & 3;
tft.setRotation(aspect);
for (iter = 0; iter < sizeof(colors) / sizeof(uint16_t); iter++) {
color = colors[iter];
tft.fillScreen(color);
tft.setTextColor(WHITE);
tft.setTextSize(1);
tft.setCursor(0, 0);
sprintf(buf, "ID=0x%04X Background=%04X %s",
tft.readID(), color, aspectname[aspect]);
tft.println(buf);
colordump(6 * 6, 0);
// duffcolor(color);
delay(5000);
}
}
libraries/MCUFRIEND_kbv/examples/scroll_kbv/scroll_kbv.ino
+49
View File
@@ -0,0 +1,49 @@
#include <Adafruit_GFX.h> // Hardware-specific library
#include <MCUFRIEND_kbv.h>
MCUFRIEND_kbv tft;
#define BLACK 0x0000
#define BLUE 0x001F
#define RED 0xF800
#define GREEN 0x07E0
#define CYAN 0x07FF
#define MAGENTA 0xF81F
#define YELLOW 0xFFE0
#define WHITE 0xFFFF
// work in line numbers. Font height in ht
int16_t ht = 16, top = 3, line, lines = 15, scroll;
void setup()
{
tft.reset();
uint16_t id = tft.readID();
tft.begin(id);
tft.setRotation(0); //Portrait
tft.fillScreen(BLACK);
tft.setTextColor(WHITE, BLACK);
tft.setTextSize(2); // System font is 8 pixels. ht = 8*2=16
tft.setCursor(100, 0);
tft.print("ID = 0x");
tft.println(id, HEX);
if (id == 0x9320 || id == 0x9325 || id == 0xB509) {
top = 0; // these controllers scroll full screen
lines = tft.height() / ht; // we are in portrait mode
}
if (id == 0x7783) {
tft.println("can NOT scroll");
while (1); // die.
}
tft.setCursor(0, 0);
for (line = 1; line < 21; line++) tft.println(String(line) + ": ");
}
void loop()
{
tft.setCursor(0, (scroll + top) * ht);
if (++scroll >= lines) scroll = 0;
tft.vertScroll(top * ht, lines * ht, (scroll) * ht);
tft.println(String(line) + ": [" + String(scroll) + "] ");
delay(100);
line++;
}
libraries/MCUFRIEND_kbv/examples/showBMP_OpenSmart_Uno/showBMP_OpenSmart_Uno.ino
+273
View File
@@ -0,0 +1,273 @@
// OPEN-SMART boards share the TFT data bus with SPI on 10, 11, 13
// SD.h always configures SPI for each call.
// SD.h does not turn SPI off when it has finished the call.
// Chan's fatFS (on which SD.h is based) did turn SPI on and off as required.
// You can disable this macro on a Mega because SPI is not shared
#define RESTORE_SPI_GPIO() SPCR = 0
// MCUFRIEND UNO shields have microSD on pins 10, 11, 12, 13
// The official <SD.h> library only works on the hardware SPI pins
// e.g. 11, 12, 13 on a Uno (or STM32 Nucleo)
//
// copy all your BMP files to the root directory on the microSD with your PC
// (or another directory)
#include <SPI.h> // f.k. for Arduino-1.5.2
//#define USE_SDFAT
#include <SD.h> // Use the official SD library on hardware pins
#include <Adafruit_GFX.h> // Hardware-specific library
#include <MCUFRIEND_kbv.h>
MCUFRIEND_kbv tft;
#if defined(ESP32)
#define SD_CS 5
#elif defined(USE_OPENSMART_SHIELD_PINOUT_UNO)
#define SD_CS 5
#else
#define SD_CS 10 // regular Mcufriend Uno Shield
#endif
#define NAMEMATCH "" // "" matches any name
//#define NAMEMATCH "tiger" // *tiger*.bmp
#define PALETTEDEPTH 0 // do not support Palette modes
//#define PALETTEDEPTH 8 // support 256-colour Palette
char namebuf[32] = "/"; //BMP files in root directory
//char namebuf[32] = "/bitmaps/"; //BMP directory e.g. files in /bitmaps/*.bmp
File root;
int pathlen;
void setup()
{
uint16_t ID;
Serial.begin(9600);
Serial.print("Show BMP files on TFT with ID:0x");
ID = tft.readID();
Serial.println(ID, HEX);
if (ID == 0x0D3D3) ID = 0x9481;
tft.begin(ID);
tft.fillScreen(0x001F);
tft.setTextColor(0xFFFF, 0x0000);
bool good = SD.begin(SD_CS);
if (!good) {
Serial.print(F("cannot start SD"));
while (1);
}
root = SD.open(namebuf);
pathlen = strlen(namebuf);
}
void loop()
{
char *nm = namebuf + pathlen;
File f = root.openNextFile();
uint8_t ret;
uint32_t start;
if (f != NULL) {
#ifdef USE_SDFAT
f.getName(nm, 32 - pathlen);
#else
strcpy(nm, (char *)f.name());
#endif
f.close();
RESTORE_SPI_GPIO();
strlwr(nm);
if (strstr(nm, ".bmp") != NULL && strstr(nm, NAMEMATCH) != NULL) {
Serial.print(namebuf);
Serial.print(F(" - "));
tft.fillScreen(0);
start = millis();
ret = showBMP(namebuf, 5, 5);
switch (ret) {
case 0:
Serial.print(millis() - start);
Serial.println(F("ms"));
delay(5000);
break;
case 1:
Serial.println(F("bad position"));
break;
case 2:
Serial.println(F("bad BMP ID"));
break;
case 3:
Serial.println(F("wrong number of planes"));
break;
case 4:
Serial.println(F("unsupported BMP format"));
break;
case 5:
Serial.println(F("unsupported palette"));
break;
default:
Serial.println(F("unknown"));
break;
}
}
}
else root.rewindDirectory();
}
#define BMPIMAGEOFFSET 54
#define BUFFPIXEL 20
uint16_t read16(File& f) {
uint16_t result; // read little-endian
f.read((uint8_t*)&result, sizeof(result));
return result;
}
uint32_t read32(File& f) {
uint32_t result;
f.read((uint8_t*)&result, sizeof(result));
return result;
}
uint8_t showBMP(char *nm, int x, int y)
{
File bmpFile;
int bmpWidth, bmpHeight; // W+H in pixels
uint8_t bmpDepth; // Bit depth (currently must be 24, 16, 8, 4, 1)
uint32_t bmpImageoffset; // Start of image data in file
uint32_t rowSize; // Not always = bmpWidth; may have padding
uint8_t sdbuffer[3 * BUFFPIXEL]; // pixel in buffer (R+G+B per pixel)
uint16_t lcdbuffer[(1 << PALETTEDEPTH) + BUFFPIXEL], *palette = NULL;
uint8_t bitmask, bitshift;
boolean flip = true; // BMP is stored bottom-to-top
int w, h, row, col, lcdbufsiz = (1 << PALETTEDEPTH) + BUFFPIXEL, buffidx;
uint32_t pos; // seek position
boolean is565 = false; //
uint16_t bmpID;
uint16_t n; // blocks read
uint8_t ret;
if ((x >= tft.width()) || (y >= tft.height()))
return 1; // off screen
bmpFile = SD.open(nm); // Parse BMP header
bmpID = read16(bmpFile); // BMP signature
(void) read32(bmpFile); // Read & ignore file size
(void) read32(bmpFile); // Read & ignore creator bytes
bmpImageoffset = read32(bmpFile); // Start of image data
(void) read32(bmpFile); // Read & ignore DIB header size
bmpWidth = read32(bmpFile);
bmpHeight = read32(bmpFile);
n = read16(bmpFile); // # planes -- must be '1'
bmpDepth = read16(bmpFile); // bits per pixel
pos = read32(bmpFile); // format
if (bmpID != 0x4D42) ret = 2; // bad ID
else if (n != 1) ret = 3; // too many planes
else if (pos != 0 && pos != 3) ret = 4; // format: 0 = uncompressed, 3 = 565
else if (bmpDepth < 16 && bmpDepth > PALETTEDEPTH) ret = 5; // palette
else {
bool first = true;
is565 = (pos == 3); // ?already in 16-bit format
// BMP rows are padded (if needed) to 4-byte boundary
rowSize = (bmpWidth * bmpDepth / 8 + 3) & ~3;
if (bmpHeight < 0) { // If negative, image is in top-down order.
bmpHeight = -bmpHeight;
flip = false;
}
w = bmpWidth;
h = bmpHeight;
RESTORE_SPI_GPIO();
if ((x + w) >= tft.width()) // Crop area to be loaded
w = tft.width() - x;
if ((y + h) >= tft.height()) //
h = tft.height() - y;
if (bmpDepth <= PALETTEDEPTH) { // these modes have separate palette
//bmpFile.seek(BMPIMAGEOFFSET); //palette is always @ 54
bmpFile.seek(bmpImageoffset - (4<<bmpDepth)); //54 for regular, diff for colorsimportant
bitmask = 0xFF;
if (bmpDepth < 8)
bitmask >>= bmpDepth;
bitshift = 8 - bmpDepth;
n = 1 << bmpDepth;
lcdbufsiz -= n;
palette = lcdbuffer + lcdbufsiz;
for (col = 0; col < n; col++) {
pos = read32(bmpFile); //map palette to 5-6-5
palette[col] = ((pos & 0x0000F8) >> 3) | ((pos & 0x00FC00) >> 5) | ((pos & 0xF80000) >> 8);
}
}
RESTORE_SPI_GPIO();
// Set TFT address window to clipped image bounds
tft.setAddrWindow(x, y, x + w - 1, y + h - 1);
for (row = 0; row < h; row++) { // For each scanline...
// Seek to start of scan line. It might seem labor-
// intensive to be doing this on every line, but this
// method covers a lot of gritty details like cropping
// and scanline padding. Also, the seek only takes
// place if the file position actually needs to change
// (avoids a lot of cluster math in SD library).
uint8_t r, g, b, *sdptr;
int lcdidx, lcdleft;
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 (bmpFile.position() != pos) { // Need seek?
bmpFile.seek(pos);
buffidx = sizeof(sdbuffer); // Force buffer reload
}
for (col = 0; col < w; ) { //pixels in row
lcdleft = w - col;
if (lcdleft > lcdbufsiz) lcdleft = lcdbufsiz;
for (lcdidx = 0; lcdidx < lcdleft; lcdidx++) { // buffer at a time
uint16_t color;
// Time to read more pixel data?
if (buffidx >= sizeof(sdbuffer)) { // Indeed
bmpFile.read(sdbuffer, sizeof(sdbuffer));
buffidx = 0; // Set index to beginning
r = 0;
}
switch (bmpDepth) { // Convert pixel from BMP to TFT format
case 32:
case 24:
b = sdbuffer[buffidx++];
g = sdbuffer[buffidx++];
r = sdbuffer[buffidx++];
if (bmpDepth == 32) buffidx++; //ignore ALPHA
color = tft.color565(r, g, b);
break;
case 16:
b = sdbuffer[buffidx++];
r = sdbuffer[buffidx++];
if (is565)
color = (r << 8) | (b);
else
color = (r << 9) | ((b & 0xE0) << 1) | (b & 0x1F);
break;
case 1:
case 4:
case 8:
if (r == 0)
b = sdbuffer[buffidx++], r = 8;
color = palette[(b >> bitshift) & bitmask];
r -= bmpDepth;
b <<= bmpDepth;
break;
}
lcdbuffer[lcdidx] = color;
}
RESTORE_SPI_GPIO();
tft.pushColors(lcdbuffer, lcdidx, first);
first = false;
col += lcdidx;
} // end cols
} // end rows
tft.setAddrWindow(0, 0, tft.width() - 1, tft.height() - 1); //restore full screen
ret = 0; // good render
}
bmpFile.close();
RESTORE_SPI_GPIO();
return (ret);
}
libraries/MCUFRIEND_kbv/examples/showBMP_kbv_Uno/showBMP_kbv_Uno.ino
+260
View File
@@ -0,0 +1,260 @@
// MCUFRIEND UNO shields have microSD on pins 10, 11, 12, 13
// The official <SD.h> library only works on the hardware SPI pins
// e.g. 11, 12, 13 on a Uno (or STM32 Nucleo)
//
// copy all your BMP files to the root directory on the microSD with your PC
// (or another directory)
#include <SPI.h> // f.k. for Arduino-1.5.2
//#define USE_SDFAT
#include <SD.h> // Use the official SD library on hardware pins
#include <Adafruit_GFX.h> // Hardware-specific library
#include <MCUFRIEND_kbv.h>
MCUFRIEND_kbv tft;
#if defined(ESP32)
#define SD_CS 5
#else
#define SD_CS 10
#endif
#define NAMEMATCH "" // "" matches any name
//#define NAMEMATCH "tiger" // *tiger*.bmp
#define PALETTEDEPTH 0 // do not support Palette modes
//#define PALETTEDEPTH 8 // support 256-colour Palette
char namebuf[32] = "/"; //BMP files in root directory
//char namebuf[32] = "/bitmaps/"; //BMP directory e.g. files in /bitmaps/*.bmp
File root;
int pathlen;
void setup()
{
uint16_t ID;
Serial.begin(9600);
Serial.print("Show BMP files on TFT with ID:0x");
ID = tft.readID();
Serial.println(ID, HEX);
if (ID == 0x0D3D3) ID = 0x9481;
tft.begin(ID);
tft.fillScreen(0x001F);
tft.setTextColor(0xFFFF, 0x0000);
bool good = SD.begin(SD_CS);
if (!good) {
Serial.print(F("cannot start SD"));
while (1);
}
root = SD.open(namebuf);
pathlen = strlen(namebuf);
}
void loop()
{
char *nm = namebuf + pathlen;
File f = root.openNextFile();
uint8_t ret;
uint32_t start;
if (f != NULL) {
#ifdef USE_SDFAT
f.getName(nm, 32 - pathlen);
#else
strcpy(nm, (char *)f.name());
#endif
f.close();
strlwr(nm);
if (strstr(nm, ".bmp") != NULL && strstr(nm, NAMEMATCH) != NULL) {
Serial.print(namebuf);
Serial.print(F(" - "));
tft.fillScreen(0);
start = millis();
ret = showBMP(namebuf, 5, 5);
switch (ret) {
case 0:
Serial.print(millis() - start);
Serial.println(F("ms"));
delay(5000);
break;
case 1:
Serial.println(F("bad position"));
break;
case 2:
Serial.println(F("bad BMP ID"));
break;
case 3:
Serial.println(F("wrong number of planes"));
break;
case 4:
Serial.println(F("unsupported BMP format"));
break;
case 5:
Serial.println(F("unsupported palette"));
break;
default:
Serial.println(F("unknown"));
break;
}
}
}
else root.rewindDirectory();
}
#define BMPIMAGEOFFSET 54
#define BUFFPIXEL 20
uint16_t read16(File& f) {
uint16_t result; // read little-endian
f.read((uint8_t*)&result, sizeof(result));
return result;
}
uint32_t read32(File& f) {
uint32_t result;
f.read((uint8_t*)&result, sizeof(result));
return result;
}
uint8_t showBMP(char *nm, int x, int y)
{
File bmpFile;
int bmpWidth, bmpHeight; // W+H in pixels
uint8_t bmpDepth; // Bit depth (currently must be 24, 16, 8, 4, 1)
uint32_t bmpImageoffset; // Start of image data in file
uint32_t rowSize; // Not always = bmpWidth; may have padding
uint8_t sdbuffer[3 * BUFFPIXEL]; // pixel in buffer (R+G+B per pixel)
uint16_t lcdbuffer[(1 << PALETTEDEPTH) + BUFFPIXEL], *palette = NULL;
uint8_t bitmask, bitshift;
boolean flip = true; // BMP is stored bottom-to-top
int w, h, row, col, lcdbufsiz = (1 << PALETTEDEPTH) + BUFFPIXEL, buffidx;
uint32_t pos; // seek position
boolean is565 = false; //
uint16_t bmpID;
uint16_t n; // blocks read
uint8_t ret;
if ((x >= tft.width()) || (y >= tft.height()))
return 1; // off screen
bmpFile = SD.open(nm); // Parse BMP header
bmpID = read16(bmpFile); // BMP signature
(void) read32(bmpFile); // Read & ignore file size
(void) read32(bmpFile); // Read & ignore creator bytes
bmpImageoffset = read32(bmpFile); // Start of image data
(void) read32(bmpFile); // Read & ignore DIB header size
bmpWidth = read32(bmpFile);
bmpHeight = read32(bmpFile);
n = read16(bmpFile); // # planes -- must be '1'
bmpDepth = read16(bmpFile); // bits per pixel
pos = read32(bmpFile); // format
if (bmpID != 0x4D42) ret = 2; // bad ID
else if (n != 1) ret = 3; // too many planes
else if (pos != 0 && pos != 3) ret = 4; // format: 0 = uncompressed, 3 = 565
else if (bmpDepth < 16 && bmpDepth > PALETTEDEPTH) ret = 5; // palette
else {
bool first = true;
is565 = (pos == 3); // ?already in 16-bit format
// BMP rows are padded (if needed) to 4-byte boundary
rowSize = (bmpWidth * bmpDepth / 8 + 3) & ~3;
if (bmpHeight < 0) { // If negative, image is in top-down order.
bmpHeight = -bmpHeight;
flip = false;
}
w = bmpWidth;
h = bmpHeight;
if ((x + w) >= tft.width()) // Crop area to be loaded
w = tft.width() - x;
if ((y + h) >= tft.height()) //
h = tft.height() - y;
if (bmpDepth <= PALETTEDEPTH) { // these modes have separate palette
//bmpFile.seek(BMPIMAGEOFFSET); //palette is always @ 54
bmpFile.seek(bmpImageoffset - (4<<bmpDepth)); //54 for regular, diff for colorsimportant
bitmask = 0xFF;
if (bmpDepth < 8)
bitmask >>= bmpDepth;
bitshift = 8 - bmpDepth;
n = 1 << bmpDepth;
lcdbufsiz -= n;
palette = lcdbuffer + lcdbufsiz;
for (col = 0; col < n; col++) {
pos = read32(bmpFile); //map palette to 5-6-5
palette[col] = ((pos & 0x0000F8) >> 3) | ((pos & 0x00FC00) >> 5) | ((pos & 0xF80000) >> 8);
}
}
// Set TFT address window to clipped image bounds
tft.setAddrWindow(x, y, x + w - 1, y + h - 1);
for (row = 0; row < h; row++) { // For each scanline...
// Seek to start of scan line. It might seem labor-
// intensive to be doing this on every line, but this
// method covers a lot of gritty details like cropping
// and scanline padding. Also, the seek only takes
// place if the file position actually needs to change
// (avoids a lot of cluster math in SD library).
uint8_t r, g, b, *sdptr;
int lcdidx, lcdleft;
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 (bmpFile.position() != pos) { // Need seek?
bmpFile.seek(pos);
buffidx = sizeof(sdbuffer); // Force buffer reload
}
for (col = 0; col < w; ) { //pixels in row
lcdleft = w - col;
if (lcdleft > lcdbufsiz) lcdleft = lcdbufsiz;
for (lcdidx = 0; lcdidx < lcdleft; lcdidx++) { // buffer at a time
uint16_t color;
// Time to read more pixel data?
if (buffidx >= sizeof(sdbuffer)) { // Indeed
bmpFile.read(sdbuffer, sizeof(sdbuffer));
buffidx = 0; // Set index to beginning
r = 0;
}
switch (bmpDepth) { // Convert pixel from BMP to TFT format
case 32:
case 24:
b = sdbuffer[buffidx++];
g = sdbuffer[buffidx++];
r = sdbuffer[buffidx++];
if (bmpDepth == 32) buffidx++; //ignore ALPHA
color = tft.color565(r, g, b);
break;
case 16:
b = sdbuffer[buffidx++];
r = sdbuffer[buffidx++];
if (is565)
color = (r << 8) | (b);
else
color = (r << 9) | ((b & 0xE0) << 1) | (b & 0x1F);
break;
case 1:
case 4:
case 8:
if (r == 0)
b = sdbuffer[buffidx++], r = 8;
color = palette[(b >> bitshift) & bitmask];
r -= bmpDepth;
b <<= bmpDepth;
break;
}
lcdbuffer[lcdidx] = color;
}
tft.pushColors(lcdbuffer, lcdidx, first);
first = false;
col += lcdidx;
} // end cols
} // end rows
tft.setAddrWindow(0, 0, tft.width() - 1, tft.height() - 1); //restore full screen
ret = 0; // good render
}
bmpFile.close();
return (ret);
}
libraries/MCUFRIEND_kbv/examples/showBMP_not_Uno/showBMP_not_Uno.ino
+273
View File
@@ -0,0 +1,273 @@
// MCUFRIEND UNO shields have microSD on pins 10, 11, 12, 13
// The official <SD.h> library only works on the hardware SPI pins
// e.g. 11, 12, 13 on a Uno
// e.g. 50, 51, 52 on a Mega2560
// e.g. 74, 75, 76 on a Due
//
// if you are not using a UNO, you must use Software SPI:
//
// NEW: install <SdFat.h> v2.x.x library with the Arduino Library Manager
// NEW: edit the src/SdFatConfig.h file to #define SPI_DRIVER_SELECT 2
//
// OBSOLETE SdFat v1.x.x uses a different system
// OBSOLETE v1.x.x SdFatConfig.h: #define ENABLE_SOFTWARE_SPI_CLASS 1
// OBSOLETE: SdFatSoftSpi<12, 11, 13> SD; //Bit-Bang on the Shield pins SDFat.h v1
// OBSOLETE: #define SD_CS 10
//
// copy all your BMP files to the root directory on the microSD with your PC
// (or another directory)
#include <SPI.h> // f.k. for Arduino-1.5.2
#define USE_SDFAT
#include <SdFat.h> // Use the SdFat library
#if SPI_DRIVER_SELECT != 2
#error edit SdFatConfig.h . READ THE SKETCH INSTRUCTIONS
#endif
SoftSpiDriver<12, 11, 13> softSpi; //Bit-Bang on the Shield pins SDFat.h v2
SdFat SD;
#define SD_CS SdSpiConfig(10, DEDICATED_SPI, SD_SCK_MHZ(0), &softSpi)
#include <Adafruit_GFX.h> // Hardware-specific library
#include <MCUFRIEND_kbv.h>
MCUFRIEND_kbv tft;
#define NAMEMATCH "" // "" matches any name
//#define NAMEMATCH "tiger" // *tiger*.bmp
#define PALETTEDEPTH 8 // support 256-colour Palette
char namebuf[32] = "/"; //BMP files in root directory
//char namebuf[32] = "/bitmaps/"; //BMP directory e.g. files in /bitmaps/*.bmp
File root;
int pathlen;
void setup()
{
uint16_t ID;
Serial.begin(9600);
Serial.print("Show BMP files on TFT with ID:0x");
ID = tft.readID();
Serial.println(ID, HEX);
if (ID == 0x0D3D3) ID = 0x9481;
tft.begin(ID);
tft.fillScreen(0x001F);
tft.setTextColor(0xFFFF, 0x0000);
bool good = SD.begin(SD_CS);
if (!good) {
Serial.print(F("cannot start SD"));
while (1);
}
root = SD.open(namebuf);
pathlen = strlen(namebuf);
}
void loop()
{
char *nm = namebuf + pathlen;
File f = root.openNextFile();
uint8_t ret;
uint32_t start;
if (f != NULL) {
#ifdef USE_SDFAT
f.getName(nm, 32 - pathlen);
#else
strcpy(nm, (char *)f.name());
#endif
f.close();
strlwr(nm);
if (strstr(nm, ".bmp") != NULL && strstr(nm, NAMEMATCH) != NULL) {
Serial.print(namebuf);
Serial.print(F(" - "));
tft.fillScreen(0);
start = millis();
ret = showBMP(namebuf, 5, 5);
switch (ret) {
case 0:
Serial.print(millis() - start);
Serial.println(F("ms"));
delay(5000);
break;
case 1:
Serial.println(F("bad position"));
break;
case 2:
Serial.println(F("bad BMP ID"));
break;
case 3:
Serial.println(F("wrong number of planes"));
break;
case 4:
Serial.println(F("unsupported BMP format"));
break;
case 5:
Serial.println(F("unsupported palette"));
break;
default:
Serial.println(F("unknown"));
break;
}
}
}
else root.rewindDirectory();
}
#define BMPIMAGEOFFSET 54
#define BUFFPIXEL 20
uint16_t read16(File& f) {
uint16_t result; // read little-endian
f.read(&result, sizeof(result));
return result;
}
uint32_t read32(File& f) {
uint32_t result;
f.read(&result, sizeof(result));
return result;
}
uint8_t showBMP(char *nm, int x, int y)
{
File bmpFile;
int bmpWidth, bmpHeight; // W+H in pixels
uint8_t bmpDepth; // Bit depth (currently must be 24, 16, 8, 4, 1)
uint32_t bmpImageoffset; // Start of image data in file
uint32_t rowSize; // Not always = bmpWidth; may have padding
uint8_t sdbuffer[3 * BUFFPIXEL]; // pixel in buffer (R+G+B per pixel)
uint16_t lcdbuffer[(1 << PALETTEDEPTH) + BUFFPIXEL], *palette = NULL;
uint8_t bitmask, bitshift;
boolean flip = true; // BMP is stored bottom-to-top
int w, h, row, col, lcdbufsiz = (1 << PALETTEDEPTH) + BUFFPIXEL, buffidx;
uint32_t pos; // seek position
boolean is565 = false; //
uint16_t bmpID;
uint16_t n; // blocks read
uint8_t ret;
if ((x >= tft.width()) || (y >= tft.height()))
return 1; // off screen
bmpFile = SD.open(nm); // Parse BMP header
bmpID = read16(bmpFile); // BMP signature
(void) read32(bmpFile); // Read & ignore file size
(void) read32(bmpFile); // Read & ignore creator bytes
bmpImageoffset = read32(bmpFile); // Start of image data
(void) read32(bmpFile); // Read & ignore DIB header size
bmpWidth = read32(bmpFile);
bmpHeight = read32(bmpFile);
n = read16(bmpFile); // # planes -- must be '1'
bmpDepth = read16(bmpFile); // bits per pixel
pos = read32(bmpFile); // format
if (bmpID != 0x4D42) ret = 2; // bad ID
else if (n != 1) ret = 3; // too many planes
else if (pos != 0 && pos != 3) ret = 4; // format: 0 = uncompressed, 3 = 565
else if (bmpDepth < 16 && bmpDepth > PALETTEDEPTH) ret = 5; // palette
else {
bool first = true;
is565 = (pos == 3); // ?already in 16-bit format
// BMP rows are padded (if needed) to 4-byte boundary
rowSize = (bmpWidth * bmpDepth / 8 + 3) & ~3;
if (bmpHeight < 0) { // If negative, image is in top-down order.
bmpHeight = -bmpHeight;
flip = false;
}
w = bmpWidth;
h = bmpHeight;
if ((x + w) >= tft.width()) // Crop area to be loaded
w = tft.width() - x;
if ((y + h) >= tft.height()) //
h = tft.height() - y;
if (bmpDepth <= PALETTEDEPTH) { // these modes have separate palette
//bmpFile.seek(BMPIMAGEOFFSET); //palette is always @ 54
bmpFile.seek(bmpImageoffset - (4<<bmpDepth)); //54 for regular, diff for colorsimportant
bitmask = 0xFF;
if (bmpDepth < 8)
bitmask >>= bmpDepth;
bitshift = 8 - bmpDepth;
n = 1 << bmpDepth;
lcdbufsiz -= n;
palette = lcdbuffer + lcdbufsiz;
for (col = 0; col < n; col++) {
pos = read32(bmpFile); //map palette to 5-6-5
palette[col] = ((pos & 0x0000F8) >> 3) | ((pos & 0x00FC00) >> 5) | ((pos & 0xF80000) >> 8);
}
}
// Set TFT address window to clipped image bounds
tft.setAddrWindow(x, y, x + w - 1, y + h - 1);
for (row = 0; row < h; row++) { // For each scanline...
// Seek to start of scan line. It might seem labor-
// intensive to be doing this on every line, but this
// method covers a lot of gritty details like cropping
// and scanline padding. Also, the seek only takes
// place if the file position actually needs to change
// (avoids a lot of cluster math in SD library).
uint8_t r, g, b, *sdptr;
int lcdidx, lcdleft;
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 (bmpFile.position() != pos) { // Need seek?
bmpFile.seek(pos);
buffidx = sizeof(sdbuffer); // Force buffer reload
}
for (col = 0; col < w; ) { //pixels in row
lcdleft = w - col;
if (lcdleft > lcdbufsiz) lcdleft = lcdbufsiz;
for (lcdidx = 0; lcdidx < lcdleft; lcdidx++) { // buffer at a time
uint16_t color;
// Time to read more pixel data?
if (buffidx >= sizeof(sdbuffer)) { // Indeed
bmpFile.read(sdbuffer, sizeof(sdbuffer));
buffidx = 0; // Set index to beginning
r = 0;
}
switch (bmpDepth) { // Convert pixel from BMP to TFT format
case 32:
case 24:
b = sdbuffer[buffidx++];
g = sdbuffer[buffidx++];
r = sdbuffer[buffidx++];
if (bmpDepth == 32) buffidx++; //ignore ALPHA
color = tft.color565(r, g, b);
break;
case 16:
b = sdbuffer[buffidx++];
r = sdbuffer[buffidx++];
if (is565)
color = (r << 8) | (b);
else
color = (r << 9) | ((b & 0xE0) << 1) | (b & 0x1F);
break;
case 1:
case 4:
case 8:
if (r == 0)
b = sdbuffer[buffidx++], r = 8;
color = palette[(b >> bitshift) & bitmask];
r -= bmpDepth;
b <<= bmpDepth;
break;
}
lcdbuffer[lcdidx] = color;
}
tft.pushColors(lcdbuffer, lcdidx, first);
first = false;
col += lcdidx;
} // end cols
} // end rows
tft.setAddrWindow(0, 0, tft.width() - 1, tft.height() - 1); //restore full screen
ret = 0; // good render
}
bmpFile.close();
return (ret);
}
libraries/MCUFRIEND_kbv/examples/testcard_kbv/testcard_kbv.ino
+193
View File
@@ -0,0 +1,193 @@
/*
* generate testcard similar to BMP
*/
#include <Adafruit_GFX.h>
#if defined(_GFXFONT_H_) //are we using the new library?
#include <Fonts/FreeSans9pt7b.h>
#define ADJ_BASELINE 11 //new fonts setCursor to bottom of letter
#else
#define ADJ_BASELINE 0 //legacy setCursor to top of letter
#endif
#include <MCUFRIEND_kbv.h>
MCUFRIEND_kbv tft;
#define BLACK 0x0000
#define BLUE 0x001F
#define RED 0xF800
#define GREEN 0x07E0
#define CYAN 0x07FF
#define MAGENTA 0xF81F
#define YELLOW 0xFFE0
#define WHITE 0xFFFF
#define RGB(r, g, b) (((r&0xF8)<<8)|((g&0xFC)<<3)|(b>>3))
#define GREY RGB(127, 127, 127)
#define DARKGREY RGB(64, 64, 64)
#define TURQUOISE RGB(0, 128, 128)
#define PINK RGB(255, 128, 192)
#define OLIVE RGB(128, 128, 0)
#define PURPLE RGB(128, 0, 128)
#define AZURE RGB(0, 128, 255)
#define ORANGE RGB(255,128,64)
#include <stdio.h>
uint16_t ID;
uint8_t hh, mm, ss; //containers for current time
uint8_t conv2d(const char* p)
{
uint8_t v = 0;
if ('0' <= *p && *p <= '9') v = *p - '0';
return 10 * v + *++p - '0';
}
void setup(void)
{
Serial.begin(9600);
tft.reset();
ID = tft.readID();
Serial.print("TFT ID = 0x");
Serial.println(ID, HEX);
// if (ID == 0xD3D3) ID = 0x9481; // write-only shield
if (ID == 0xD3D3) ID = 0x9486; // write-only shield
tft.begin(ID);
tft.setRotation(1);
tft.fillScreen(BLACK);
#if defined(_GFXFONT_H_)
tft.setFont(&FreeSans9pt7b);
#endif
hh = conv2d(__TIME__);
mm = conv2d(__TIME__ + 3);
ss = conv2d(__TIME__ + 6);
}
void loop(void)
{
int16_t x, y, dx, dy, radius = 108, idx;
uint16_t w, h, len, mask;
uint16_t colors[8] = { BLACK, WHITE, YELLOW, CYAN, GREEN, MAGENTA, RED, BLUE };
uint16_t height, width;
width = tft.width();
height = tft.height();
tft.fillRect(0, 0, 7, 3, WHITE);
tft.fillRect(313, 0, 7, 3, WHITE);
tft.fillRect(0, 237, 7, 3, WHITE);
tft.fillRect(313, 237, 7, 3, WHITE);
for (y = 0, w = 18, h = 3; y < 240; y += 13 * w + h) {
for (x = 25; x < 320 - 18; x += 2 * w) {
tft.fillRect(x, y, w, h, WHITE);
}
}
for (x = 0, w = 7, h = 18; x < 320; x += 17 * h + w) {
for (y = 21; y < 240 - 18; y += 2 * h) {
tft.fillRect(x, y, w, h, WHITE);
}
}
tft.fillRect(7, 3, 17 * 18, 13 * 18, GREY);
for (x = 7, y = 0, w = 1, h = 240; x < 320; x += 18) {
tft.fillRect(x, y, w, h, WHITE);
}
for (x = 0, y = 3, w = 320, h = 1; y < 240; y += 18) {
tft.fillRect(x, y, w, h, WHITE);
}
tft.fillRect(26, 22, 17, 99, TURQUOISE);
tft.fillRect(26, 120, 17, 99, PINK);
tft.fillRect(44, 22, 17, 35, AZURE);
tft.fillRect(44, 184, 17, 35, ORANGE);
tft.fillRect(260, 22, 17, 35, AZURE);
tft.fillRect(260, 184, 17, 35, ORANGE);
tft.fillRect(278, 22, 17, 99, OLIVE);
tft.fillRect(278, 120, 17, 99, PURPLE);
for (dx = radius; dx > -radius; dx--) {
w = sqrt(radius * radius - dx * dx);
y = 120 - dx;
dy = (y - 3) / 18;
mask = 7;
colors[0] = (dy == 3) ? DARKGREY : BLACK;
switch (dy) {
case 0:
case 1: idx = 1; len = 0; break;
case 2: idx = 0; len = 0; break;
case 3: idx = 0; len = 13; mask = 1; break;
case 4:
case 5: idx = 2; len = 38; break;
case 6:
case 7:
case 8: idx = 0; len = 0; break;
case 9: for (idx = 2; idx < 8; idx++) {
//dy = 0xFF >> (7 - idx);
dy = (idx - 2) * 51;
colors[idx] = tft.color565(dy, dy, dy);
}
idx = 2; len = 38; break;
case 10: idx = 1; len = 0; break;
case 11:
case 12: colors[2] = YELLOW; idx = 2; len = 0; break;
}
if (len == 0)
tft.fillRect(160 - w, y, w * 2, 1, colors[idx]);
else {
if (mask == 1) idx = 1 + (w) / len;
dy = w % len;
for (x = 160 - w; x < 160 + w; idx++) {
tft.fillRect(x, y, dy, 1, colors[idx & mask]);
x += dy;
if (x + len > 160 + w) dy = w % len;
else dy = len;
}
}
}
for (x = 72, y = 129, dx = 5, dy = 0; dx > 0; x += 2 * dx) {
tft.fillRect(x, y, dx, 36, WHITE);
dy += dx * 2;
if (dy >= 36) {
dy = 0;
dx--;
}
}
tft.fillRect(160 - 8, 5 * 18 + 3, 17, 3 * 18, BLACK);
for (x = 3 * 18 + 7, y = 6 * 18 + 3, w = 1, h = 18; x < 160 + 108; x += 18) {
tft.fillRect(x, y, w, h, WHITE);
}
tft.fillRect(160 - 108, 120, 108 * 2, 1, WHITE);
tft.fillRect(160, 5 * 18 + 3, 1, 3 * 18, WHITE);
tft.fillRect(108, 2 * 18 + 3, 6 * 18, 18, WHITE);
// tft.fillRect(108, 10 * 18 + 3, 6 * 18, 18, BLACK);
tft.fillRect(160 - 8, 11 * 18 + 3, 17, radius - 18*9/2, RED);
tft.setCursor(160 - 36, 24 + ADJ_BASELINE);
tft.setTextColor(BLACK);
tft.setTextSize(1);
tft.print("320x240");
tft.setCursor(109, 43 + ADJ_BASELINE);
tft.setTextColor(BLACK);
tft.setTextSize(1);
tft.print("ID=0x");
tft.print(tft.readID(), HEX);
tft.setTextColor(WHITE, BLACK);
// tft.setFont(NULL);
// tft.setTextSize(2);
while (1) {
if (++ss > 59) {
ss = 0;
mm++;
if (mm > 59) {
mm = 0;
hh++;
if (hh > 23) hh = 0;
}
}
char buf[20];
sprintf(buf, "%02d:%02d:%02d", hh, mm, ss);
tft.fillRect(108, 10 * 18 + 3, 6 * 18, 18, BLACK);
tft.setCursor(128, 187 + ADJ_BASELINE);
tft.print(buf);
delay(1000);
}
}
libraries/MCUFRIEND_kbv/extras/bitmaps/betty_1.bmp
BIN
View File
Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 8.8 KiB

libraries/MCUFRIEND_kbv/extras/bitmaps/betty_4.bmp
BIN
View File
Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 26 KiB

libraries/MCUFRIEND_kbv/extras/bitmaps/marilyn_240x240x8.bmp
BIN
View File
Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 57 KiB

libraries/MCUFRIEND_kbv/extras/bitmaps/miniwoof.bmp
BIN
View File
Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 56 KiB

libraries/MCUFRIEND_kbv/extras/bitmaps/test.bmp
BIN
View File
Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 225 KiB

libraries/MCUFRIEND_kbv/extras/bitmaps/tiger.bmp
BIN
View File
Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 225 KiB

libraries/MCUFRIEND_kbv/extras/bitmaps/tiger16T.bmp
BIN
View File
Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 150 KiB

libraries/MCUFRIEND_kbv/extras/bitmaps/tiger_178x160x4.bmp
BIN
View File
Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 14 KiB

libraries/MCUFRIEND_kbv/extras/bitmaps/tiger_240x317x4.bmp
BIN
View File
Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 37 KiB

libraries/MCUFRIEND_kbv/extras/bitmaps/tiger_320x200x24.bmp
BIN
View File
Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 188 KiB

libraries/MCUFRIEND_kbv/extras/bitmaps/woof.bmp
BIN
View File
Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 225 KiB

libraries/MCUFRIEND_kbv/extras/mcufriend_history.txt
+115
View File
@@ -0,0 +1,115 @@
CHANGE HISTORY:
Will Never Happen:
R61520, R61526 vert scroll is not possible
ST7781 vert scroll is not implemented
ILI9320, 9325, ... can never vert scroll sub-window i.e. no Band Scroll
To Be Fixed:
R61505, 0x1511, HX8347-A, S6D0139
v2.9.4-beta:
readReg() accepts an optional index argument
pushColors() from Flash accepts an optional bigend argument
added UC8230, R61505, HX8367-A
v2.9.3:
added R61526
file structure changed
v2.9.1:
added HX8357-D, R61581,
v2.9: posted 05 May 2016
MCUFRIEND_kbv.cpp:
Added pushCommand() method to send block of 8-bit SRAM data to MIPI controller
SSD1963 fixed aspects.
Added ILI9302
Added ILI9338
Added R61520
ILI9327 defaults to shifted band in REV modes. #define OFFSET_9327
Conditional S6D0139. #define SUPPORT_0139 Untested
Conditional HX8347-A. #define SUPPORT_8347A Untested
Conditional HX8347-I. #define SUPPORT_8347D
Conditional SSD1289. #define SUPPORT_1289
UTFTGLUE.h:
implement drawBitmap() method. (no rotations)
LCD_ID_readreg.ino:
write(0xB0, 0x00) after hardware Reset to read manufacturer locations.
added some extra registers.
v2.8: posted 26 February 2016
MCUFRIEND_kbv.cpp: LANDSCAPE is now 90 degrees instead of 270 degrees
methods branch on MIPI / 9320 style
Added SPFD5408
Added R61505W Untested
Added HX8347-A Untested
Added SSD1963 Untested
graphictest_kbv.ino: smaller buffer for Software Scroll. Just fits in Uno Flash
TouchScreen_Calibr_kbv: wait for consistent Touch
LCD_ID_readreg: Added some more registers
v2.7: posted ........ NOT YET
v2.6: posted ........ NOT YET
MCUFRIEND_kbv.cpp:
Added R65105V
v2.5: posted 11 January 2016
MCUFRIEND_kbv.cpp:
Added ST7789V
Added RM68090
Added ILI9481
Added pushColors() from Flash
Improved downward Vertical Scroll. API is changed.
ILI9327 should work in all aspects. vertical scroll in PORT/LAND_REV
S6D0154 should vertical scroll a subwindow
graphictest_kbv.ino: smooth colour gradation on rounded rectangle tests on bigger displays
added colour grading range.
added vertical scroll down
improve messages
graphictest_slim.ino: reduced-fat version of graphictest_kbv.ino
testcard_kbv.ino: drawn version of common BMP photo.
scroll_kbv.ino: changed vertScroll() call for new API
UTFTGLUE.h: improve calculate width and height of rectangles from coordinates.
v2.4: posted 10 December 2015
MCUFRIEND_kbv.cpp: LGDP4535 initialisation table fixed - UNTESTED
v2.3: posted 8 December 2015
MCUFRIEND_kbv.cpp: added S6D0139 UNTESTED
detect EXTC=0 ILI9341 shield from DX with ID == 0x0000. drive in RGB mode
ILI9327 should Vertical Scroll now. UNTESTED
UTFTGLUE.h: extra print(const char*) method to avoid warning messages
graphictest_kbv.ino: software scroll a smaller block at top of screen
GLUE_Demo_320x240: removed unnecessary "include Adafruit_TFTLCD.h"
aspect_kbv.ino: invert display when in different aspects
readpixel_kbv.ino: support smaller geometries
LCD_ID_readreg.ino: report some more regs
TouchScreen_Calibr_kbv: for resistive Touch screens like on Mcufriend shields
UTouch_Calibr_kbv: can use UTouch.h library for hardware Touch Controllers (and UTFT)
v2.2: posted 15 November 2015
MCUFRIEND_kbv.cpp: changed readGRAM() for ILI9327, ILI9486,
added REV_SCREEN flag to _lcd_capable
implement invertDisplay()
added LGDP4535
ILI9327: set Partial Area to 0, 399
MCUFRIEND_kbv.h: USE_GFX_KBV default argument: println(char *s="")
MCUFRIEND_shield.h: regular Uno shield drivers for Uno, Mega, Leonardo, Due, Zero
MCUFRIEND_special.h: experimental drivers
UTFTGLUE.h: identity kludges for non-UNO shields
LCD_ID_readreg.ino: report reg(0x09)
v2.1: posted 9 November 2015
MCUFRIEND_kbv.cpp: return 0x9327 / 0x9481 in readID()
MCUFRIEND_shield.h: increase low pulse width in RD_STROBE
EXAMPLES/: add scroll_kbv.ino sketch
edit readpixel_kbv_ino, aspect_kbv.ino
v2.0: posted 8 November 2015
Massive changes from v1.0
libraries/MCUFRIEND_kbv/extras/mcufriend_how_to.txt
+156
View File
@@ -0,0 +1,156 @@
1. The Arduino Library Manager should find and install MCUFRIEND_kbv library
2. Install the Adafruit_GFX library if not already in your User libraries.
3. Insert your Mcufriend style display shield into UNO. Only 28-pin shields are supported.
4. Build any of the Examples from the File->Examples->Mcufriend_kbv menu. e.g. graphictest_kbv.ino
5. Most of them will write some text to the Serial window (9600 baud). The BMP examples require you to copy the pictures from the bitmaps/ folder to your microSD (root directory)
6. This library is only intended for UNO and these specific Shields. It will work on a MEGA2560 but not very fast.
7. The constructor takes no arguments (because it only works with these shields)
8. The examples are the standard Adafruit ones. You can see my edits by searching for "kbv"
9. Any Adafruit sketch should work with the MCUFRIEND_kbv constructor() but should allow extra ID values
An Adafruit constructor(cs, rs, wr, rd, rst) IGNORES any arguments. i.e. it only uses the shield control pins
MCUFRIEND_kbv inherits all the methods from
the Adafruit_GFX class: https://learn.adafruit.com/adafruit-gfx-graphics-library/overview
and Print class: https://www.arduino.cc/en/Serial/Print
The only "new" methods are hardware related:
vertScroll(), readGRAM(), readPixel(), setAddrWindow(), pushColors(), readID(), begin()
readReg(), pushCommand(), WriteCmdData() access the controller registers
10. It currently supports UNO shields with "mcufriend.com" pcbs with controllers:
GC9302 240x320 ID=0x9302
HX8347-A 240x320 ID=0x8347 #define SUPPORT_8347A *** Untested ***
HX8347-D 240x320 ID=0x4747 #define SUPPORT_8347D
HX8347-G 240x320 ID=0x7575 #define SUPPORT_8347D
HX8347-I 240x320 ID=0x9595 #define SUPPORT_8347D
HX8352-A 240x400 ID=0x5252 #define SUPPORT_8352A
HX8352-B 240x400 ID=0x0065 #define SUPPORT_8352B
HX8357-B 320x480 ID=0x8357 (shares init with 8357-D)
HX8357-C 320x480 ID=0x9090 (ID has changed from 0x8357)
HX8357-D 320x480 ID=0x0099 #define SUPPORT_8357D_GAMMA
HX8367-A 240x320 ID=0x6767 #define SUPPORT_8347D
ILI9163 128x160 ID=0x9163 #define SUPPORT_9163
ILI9225 176x220 ID=0x9225 #define SUPPORT_9225
ILI9226 176x220 ID=0x9226 #define SUPPORT_9225
ILI9320 240x320 ID=0x9320
ILI9325 240x320 ID=0x9325
ILI9326 240x400 ID=0x9326 #define SUPPORT_9326_5420
ILI9327 240x400 ID=0x9327
ILI9328 240x320 ID=0x9328
ILI9329 240x320 ID=0x9329
ILI9331 240x320 ID=0x9331
ILI9335 240x320 ID=0x9335
ILI9338 240x320 ID=0x9338
ILI9340 240x320 ID=0x9340
ILI9341 240x320 ID=0x9341
ILI9342 320x240 ID=0x9342 #define SUPPORT_9342
ILI9481 320x480 ID=0x9481
ILI9486 320x480 ID=0x9486
ILI9487 320x480 ID=0x9487
ILI9488 320x480 ID=0x9488 (weird 555 display :#define SUPPORT_9488_555)
LGDP4532 240x320 ID=0x4532 #define SUPPORT_4532
LGDP4535 240x320 ID=0x4535 #define SUPPORT_4535
NT35310 320x480 ID=0x5310 (hardware must be set for 8-bit parallel)
NT37502 240x320 ID=0x1602 no readGRAM() or readPixel()
R61505 240x320 ID=0x1505 works like an ILI9320
R61505V 240x320 ID=0xB505
R61505W 240x320 ID=0xC505
R61509V 240x400 ID=0xB509 #define SUPPORT_B509_7793
R61520 240x320 ID=0x1520 (no Vertical Scroll)
R61526A 240x320 ID=0x1526 (no Vertical Scroll) configure NVM with sketch
R61580 240x320 ID=0x1580 #define SUPPORT_1580 *** Untested ***
R61581 320x480 ID=0x1581
RM68090 240x320 ID=0x6809
RM68130 176x220 ID=0x6813 #define SUPPORT_9225
RM68140 320x480 ID=0x6814 #define SUPPORT_68140
S6D0139 240x320 ID=0x0139 #define SUPPORT_0139 (no Band Scroll)
S6D0154 240x320 ID=0x0154 #define SUPPORT_0154
SPFD5408 240x320 ID=0x5408
SPFD5420 240x400 ID=0x5420 #define SUPPORT_9326_5420
SSD1963 800x480 ID=0x1963
SSD1289 240x320 ID=0x1289 #define SUPPORT_1289
SSD1297 240x320 ID=0x9797 #define SUPPORT_1289 (unstable readGRAM())
ST7735 128x160 ID=0x7735 #define SUPPORT_7735 (untested)
ST7781 240x320 ID=0x7783 #define SUPPORT_7781 (no Vertical Scroll)
ST7789V 240x320 ID=0x7789
ST7793 240x400 ID=0x7793 #define SUPPORT_B509_7793
ST7796 320x480 ID=0x7796
UC8230 240x320 ID=0x8230 #define SUPPORT_8230
UNKNOWN 320x480 ID=0x1511 (scroll directions not correct)
UNKNOWN 240x320 ID=0xAC11
UNKNOWN 240x320 ID=0x2053 weird controller from BangGood (was ID=0x0000)
UNKNOWN 240x320 ID=0x8031 (no Vertical Scroll)
UNKNOWN 240x320 ID=0x0001 (0x9320 style)
UNKNOWN 240x320 ID=0x3229 readGRAM() does not work properly. NEED DATASHEET.
UNKNOWN 240x320 ID=0xE300 weird controller from BangGood. NEED DATASHEET
Most of these controllers are #define SUPPORT_xxxx by default.
You can save Flash memory on a Uno by commenting out the macro(s) in MCUFRIEND_kbv.cpp
11. It should run on a UNO, MEGA2560, LEONARDO, DUE, ZERO, M0-PRO,
It also runs on NUCLEO-F103 and TEENSY3.2 with Sparkfun Adapter
12. These Mcufriend-style shields tend to have a resistive TouchScreen on A1, 7, A2, 6 but are not always the same rotation of direction.
The TouchScreen_Calibr_native.ino sketch wiil diagnose Touch Pins, do Calibration, report to Serial Terminal.
The Calibration should work with the TouchScreen.h library from Adafruit.
You can always copy the local TouchScreen_kbv.h library from sketch to the global user libraries folder.
13. The graphictest_kbv.ino sketch runs the standard Adafruit tests and reports the execution time.
The Scroll tests show each screen rotation, colours, scroll directions, colour inversion.
Vertical scroll is up/down in Portrait modes. Left/right in Landscape
Band Scroll should just move the coloured Band. ILI9320 style will always move the whole screen.
The text "SOFTWARE SCROLL" should move horizontally across the screen or report a readPixel() ERROR.
14. The scroll_kbv.ino sketch should scroll a window or subwindow for most chips. Not all chips can scroll.
15. The readpixel_kbv.ino sketch should display memory in each aspect.
16. The GLUE_Demo_320x240.ino sketch uses a "GLUE" class to display a UTFT sketch on supported mcufriend shields.
It is NOT perfect. Please report any problems. It is designed as a CONVENIENCE for legacy UTFT code.
Please use MCUFRIEND_kbv method()s in new code.
17. If you do not have a standard Uno Shield, you can add a SPECIAL to the mcufriend_special.h
Edit mcufriend_shield.h: #define USE_SPECIAL
Edit mcufriend_special.h: e.g. #define USE_MEGA_16BIT_SHIELD
If your "special" is write-only, the library can not read the ID. It always returns 0xD3D3
18. Please run LCD_ID_readreg.ino to verify your non-standard wiring. Paste the defines to a Forum message.
19. OPEN-SMART Shields have different wiring to regular Uno Shields:
Edit utility/mcufriend_shield.h: #define USE_SPECIAL
Edit utility/mcufriend_special.h: #define USE_OPENSMART_SHIELD_PINOUT_xxx e.g. USE_OPENSMART_SHIELD_PINOUT_MEGA
Edit MCUFRIEND_kbv.cpp: #define SUPPORT_8352B
20. OPEN-SMART Shields can not read LM75A on a Mega because there are no SDA/SCL pins next on AREF header.
Uno: LM75A on pcb works. Difficult to add external I2C devices when Shield is plugged in.
Uno: All use of SPI bus should use SPI.beginTransaction(), SPI.endTransaction()
Leo: I do not support USE_OPENSMART_SHIELD_PINOUT_LEO
Mega: Old boards do not have SDA/SCL on AREF header. Only external I2C devices on COMMS header
Due: MAX809 Reset chip interferes with 3.3V RST on SPI header. Manual reset for Upload / Run.
21. BLUEPILL Adapter standard wiring is:
//LCD pins |D7 |D6 |D5 |D4 |D3 |D2 |D1 |D0 | |RD |WR |RS |CS |RST| |SD_SS|SD_DI|SD_DO|SD_SCK|
//STM32 pin |PA7|PA6|PA5|PA4|PA3|PA2|PA1|PA0| |PB0|PB6|PB7|PB8|PB9| |PA15 |PB5 |PB4 |PB3 | **ALT-SPI1**
Maple core: to use SPI2 for SPI. edit SPI.cpp for SPIClass SPI(2);
STM Core: to use SPI2 for SPI. edit variant.h to use PA15, PB3, PB4, PB5 for SPI_SS etc
Touchscreen needs XM, YP to be on Analog capable pins. Measure resistance with DMM to determine X, Y
300R pair is XP, XM. 500R pair is YP, YM. choose XM, YP from PA7, PA6. XP, YM from PB6, PB7
Run the Calibration sketch to get accurate TS_LEFT, TS_RT, TS_TOP, TS_BOT values.
Ignore the XP, XM, ... values. They mean nothing on a BluePill
Adafruit_Touchscreen might need: typedef volatile uint32_t RwReg;
Maple core: use Touchscreen_kbv library
STM Core: regular Touchscreen libraries should be ok.
CHANGE HISTORY: is now in "mcufriend_history.txt"
libraries/MCUFRIEND_kbv/extras/unused/ADA_GFX_kbv.cpp
+500
View File
@@ -0,0 +1,500 @@
/*
This is the core graphics library for all our displays, providing a common
set of graphics primitives (points, lines, circles, etc.). It needs to be
paired with a hardware-specific library for each display device we carry
(to handle the lower-level functions).
Adafruit invests time and resources providing this open source code, please
support Adafruit & open-source hardware by purchasing products from Adafruit!
Copyright (c) 2013 Adafruit Industries. All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
- Redistributions of source code must retain the above copyright notice,
this list of conditions and the following disclaimer.
- Redistributions in binary form must reproduce the above copyright notice,
this list of conditions and the following disclaimer in the documentation
and/or other materials provided with the distribution.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
POSSIBILITY OF SUCH DAMAGE.
*/
#include "ADA_GFX_kbv.h"
#ifdef __AVR__
#include <avr/pgmspace.h>
#include <stdio.h>
extern "C" unsigned int abs(int);
#else
#define pgm_read_byte(addr) (*(const unsigned char *)(addr))
#define PROGMEM
#include <stdio.h>
extern "C" unsigned int abs(int);
#endif
#include "glcdfont.inc"
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;
}
// 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(x0, y0);
swap(x1, y1);
}
if (x0 > x1) {
swap(x0, x1);
swap(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(y0, y1); swap(x0, x1);
}
if (y1 > y2) {
swap(y2, y1); swap(x2, x1);
}
if (y0 > y1) {
swap(y0, y1); swap(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(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(a,b);
drawFastHLine(a, y, b-a+1, color);
}
}
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;
for(j=0; j<h; j++) {
for(i=0; i<w; i++ ) {
if(pgm_read_byte(bitmap + j * byteWidth + i / 8) & (128 >> (i & 7))) {
drawPixel(x+i, y+j, color);
}
}
}
}
#if defined(ARDUINO) && ARDUINO < 100
virtual void Adafruit_GFX::write(uint8_t c) {
#else
size_t Adafruit_GFX::write(uint8_t c) {
#endif
if (c == '\n') {
cursor_y += textsize*8;
cursor_x = 0;
} else if (c == '\r') {
// skip em
} else {
drawChar(cursor_x, cursor_y, c, textcolor, textbgcolor, textsize);
cursor_x += textsize*6;
if (wrap && (cursor_x > (_width - textsize*6))) {
cursor_y += textsize*8;
cursor_x = 0;
}
}
#if !(defined(ARDUINO) && 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((x >= _width) || // Clip right
(y >= _height) || // Clip bottom
((x + 6 * size - 1) < 0) || // Clip left
((y + 8 * size - 1) < 0)) // Clip top
return;
for (int8_t i=0; i<6; i++ ) {
uint8_t line;
if (i == 5)
line = 0x0;
else
line = pgm_read_byte(font+(c*5)+i);
for (int8_t j = 0; j<8; j++) {
if (line & 0x1) {
if (size == 1) // default size
drawPixel(x+i, y+j, color);
else { // big size
fillRect(x+(i*size), y+(j*size), size, size, color);
}
} else if (bg != color) {
if (size == 1) // default size
drawPixel(x+i, y+j, bg);
else { // big size
fillRect(x+i*size, y+j*size, size, size, bg);
}
}
line >>= 1;
}
}
}
void Adafruit_GFX::setCursor(int16_t x, int16_t y) {
cursor_x = x;
cursor_y = 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;
}
}
// 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
}
// this looks the most convenient method of all. i.e. forget about print() and println()
// and could be part of ADA_GFX_kbv.cpp. possibly overwritten by later classes.
// possibly use global buffer rather than stack.
#include <stdarg.h>
int Adafruit_GFX::printf(const char* format, ...)
{
char buffer[80];
va_list args;
va_start (args, format);
vsnprintf (buffer, 80, format, args);
for (char *p = buffer; *p; p++) write(*p);
va_end (args);
return strlen(buffer);
}
libraries/MCUFRIEND_kbv/extras/unused/ADA_GFX_kbv.h
+113
View File
@@ -0,0 +1,113 @@
#ifndef _ADAFRUIT_GFX_H
#define _ADAFRUIT_GFX_H
//#define USE_VFONTS
#include "Arduino.h"
#define boolean bool
#ifndef HEX
#define DEC 0
#define HEX 1
#endif
#define swap(a, b) { int16_t t = a; a = b; b = t; }
class Adafruit_GFX { //: public Stream { // requires an interface
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),
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);
#if defined(ARDUINO) && ARDUINO < 100
virtual void write(uint8_t);
#else
virtual size_t write(uint8_t);
#endif
int printf(const char* format, ...);
void print(const char *s) { printf("%s", s); }
void print(char *s) { printf("%s", s); }
void print(char c) { printf("%c", c); }
void print(uint8_t v) { printf("%u", v); }
void print(int16_t v) { printf("%d", v); }
void print(int32_t vl) { printf("%ld", vl); }
void print(double vd, int =2) { printf("%0.2f", vd); }
void println(uint8_t u, int fmt=0) { if (fmt == 0) printf("%u\n", u); else printf("%04X\n", u); }
void println(uint16_t u, int fmt=0) { if (fmt == 0) printf("%u\n", u); else printf("%04X\n", u); }
void println(uint32_t ul, int fmt=0) { if (fmt == 0) printf("%lu\n", ul); else printf("%04lX\n", ul); }
void println(const char *s="") { printf("%s\n", s); }
void println(double vd, int prec=2) { printf("%0.2f\n", vd); }
int16_t
height(void),
width(void);
uint8_t getRotation(void);
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
#if defined USE_VFONTS
public:
void setFont(const PROGMEM uint8_t *ads, uint8_t mode = 0);
void drawFontChar(int16_t x, int16_t y, uint8_t c, uint16_t color, uint16_t bg, uint8_t size);
int8_t charWidth(uint8_t c);
private:
uint8_t *vfont_ads, vfont_wid, vfont_ht, vfont_ofs, vfont_siz, vfont_mode, *vfont_letter_ads;
#endif
};
#endif // _ADAFRUIT_GFX_H
libraries/MCUFRIEND_kbv/extras/unused/ILI9341_regValues.txt
+307
View File
@@ -0,0 +1,307 @@
case 0x9341:
_lcd_capable = AUTO_READINC | TWO_PARM_WINDOW | MV_AXIS;
static const uint8_t ILI9341_regValues_kbv[] PROGMEM = { //.kbv MCUFRIEND_kbv
0x01, 0, // software reset
TFTLCD_DELAY, 150, // 5ms if awake, 125ms if asleep.
0xCB, 5, 0x39, 0x2C, 0x00, 0x34, 0x02, //Power Control A [39 2C 00 34 02]
0xCF, 3, 0x00, 0xC1, 0x30, //Power Control B [00 81 30]
0xE8, 3, 0x85, 0x00, 0x78, //Driver Timing A [04 11 7A]
0xEA, 2, 0x00, 0x00, //Driver Timing B [66 00]
0xED, 4, 0x64, 0x03, 0x12, 0x81, //Power On Seq [55 01 23 01]
0xF7, 1, 0x20, //Pump Ratio [10]
0xC0, 1, 0x23, //Power Control 1 [26]
0xC1, 1, 0x10, //Power Control 2 [00]
0xC5, 2, 0x3E, 0x28, //VCOM 1 [31 3C]
0xC7, 1, 0x86, //VCOM 2 [C0]
0x36, 1, 0x48, //Memory Access [00]
0xB1, 2, 0x00, 0x18, //Frame Control [00 1B]
0xB6, 3, 0x08, 0x82, 0x27, //Display Function [0A 82 27 XX]
0xF2, 1, 0x00, //Enable 3G [02]
0x26, 1, 0x01, //Gamma Set [01]
0xE0, 15, 0x0f, 0x31, 0x2b, 0x0c, 0x0e, 0x08, 0x4e, 0xf1, 0x37, 0x07, 0x10, 0x03, 0x0e, 0x09, 0x00,
0xE1, 15, 0x00, 0x0e, 0x14, 0x03, 0x11, 0x07, 0x31, 0xC1, 0x48, 0x08, 0x0f, 0x0c, 0x31, 0x36, 0x0f,
0x11, 0, //Sleep Out
TFTLCD_DELAY, 150,
0x29, 0, //Display On
0x3A, 1, 0x55, //Pixel Format [66]
};
static const uint8_t ILI9341_regValues_2_6[] PROGMEM = { // LG 2.6" from AN
0x01, 0, // software reset
0xCB, 5, 0x39, 0x2C, 0x00, 0x34, 0x02, //Power Control A [39 2C 00 34 02]
0xCF, 3, 0x00, 0xC1, 0x30, //Power Control B [00 81 30]
0xE8, 3, 0x85, 0x00, 0x78, //Driver Timing A [04 11 7A]
0xEA, 2, 0x00, 0x00, //Driver Timing B [66 00]
0xED, 4, 0x64, 0x03, 0x12, 0x81, //Power On Seq [55 01 23 01]
0xF7, 1, 0x20, //Pump Ratio [10]
0xC0, 1, 0x23, //Power Control 1 [26]
0xC1, 1, 0x10, //Power Control 2 [00]
0xC5, 2, 0x2B, 0x2B, //VCOM 1 [31 3C]
0xC7, 1, 0xC0, //VCOM 2 [C0]
0x36, 1, 0x48, //Memory Access [00]
0xB1, 2, 0x00, 0x1B, //Frame Control [00 1B]
// 0xB6, 3, 0x0A, 0x02, 0x27, //Display Function [0A 82 27 XX] .kbv REV=0
0xF2, 1, 0x00, //Enable 3G [02]
0x26, 1, 0x01, //Gamma Set [01]
0xE0, 15, 0x0f, 0x31, 0x2b, 0x0c, 0x0e, 0x08, 0x4e, 0xf1, 0x37, 0x07, 0x10, 0x03, 0x0e, 0x09, 0x00,
0xE1, 15, 0x00, 0x0e, 0x14, 0x03, 0x11, 0x07, 0x31, 0xC1, 0x48, 0x08, 0x0f, 0x0c, 0x31, 0x36, 0x0f,
0x11, 0, //Sleep Out
TFTLCD_DELAY, 150,
0x29, 0, //Display On
0x3A, 1, 0x55, //Pixel Format [66]
};
static const uint8_t ILI9341_regValues_2_0[] PROGMEM = { // BOE 2.0"
0x01, 0, // software reset
0xCF, 3, 0x00, 0x99, 0x30, //Power Control B [00 81 30]
0xED, 4, 0x64, 0x03, 0x12, 0x81, //Power On Seq [55 01 23 01]
0xE8, 3, 0x85, 0x10, 0x78, //Driver Timing A [04 11 7A]
0xCB, 5, 0x39, 0x2C, 0x00, 0x34, 0x02, //Power Control A [39 2C 00 34 02]
0xF7, 1, 0x20, //Pump Ratio [10]
0xEA, 2, 0x00, 0x00, //Driver Timing B [66 00]
0xC0, 1, 0x26, //Power Control 1 [26]
0xC1, 1, 0x12, //Power Control 2 [00]
0xC5, 2, 0x2B, 0x2C, //VCOM 1 [31 3C]
0xC7, 1, 0xC4, //VCOM 2 [C0]
0x36, 1, 0x08, //Memory Access [00]
0xB1, 2, 0x00, 0x1B, //Frame Control [00 1B]
// 0xB6, 3, 0x0A, 0xA2, 0x27, //?? Display Function [0A 82 27 XX] .kbv SS=1
0xF2, 1, 0x00, //Enable 3G [02]
0x26, 1, 0x01, //Gamma Set [01]
0xE0, 15, 0x0f, 0x24, 0x21, 0x0a, 0x0e, 0x09, 0x51, 0xa9, 0x44, 0x07, 0x10, 0x03, 0x2c, 0x0b, 0x00,
0xE1, 15, 0x00, 0x1b, 0x1e, 0x05, 0x11, 0x06, 0x2e, 0x56, 0x3b, 0x08, 0x0f, 0x0c, 0x13, 0x14, 0x0f,
0x11, 0, //Sleep Out
TFTLCD_DELAY, 150,
0x29, 0, //Display On
0x3A, 1, 0x55, //Pixel Format [66]
};
static const uint8_t ILI9341_regValues_2_4[] PROGMEM = { // BOE 2.4"
0x01, 0, // software reset
TFTLCD_DELAY, 50, // .kbv
0xCF, 3, 0x00, 0x81, 0x30, //Power Control B [00 81 30]
0xED, 4, 0x64, 0x03, 0x12, 0x81, //Power On Seq [55 01 23 01]
0xE8, 3, 0x85, 0x10, 0x78, //Driver Timing A [04 11 7A]
0xCB, 5, 0x39, 0x2C, 0x00, 0x34, 0x02, //Power Control A [39 2C 00 34 02]
0xF7, 1, 0x20, //Pump Ratio [10]
0xEA, 2, 0x00, 0x00, //Driver Timing B [66 00]
0xB1, 2, 0x00, 0x1B, //Frame Control [00 1B]
// 0xB6, 2, 0x0A, 0xA2, 0x27, //Display Function [0A 82 27 XX] .kbv SS=1
0xC0, 1, 0x21, //Power Control 1 [26]
0xC1, 1, 0x11, //Power Control 2 [00]
0xC5, 2, 0x3F, 0x3C, //VCOM 1 [31 3C]
0xC7, 1, 0xB5, //VCOM 2 [C0]
0x36, 1, 0x48, //Memory Access [00]
0xF2, 1, 0x00, //Enable 3G [02]
0x26, 1, 0x01, //Gamma Set [01]
0xE0, 15, 0x0f, 0x26, 0x24, 0x0b, 0x0e, 0x09, 0x54, 0xa8, 0x46, 0x0c, 0x17, 0x09, 0x0f, 0x07, 0x00,
0xE1, 15, 0x00, 0x19, 0x1b, 0x04, 0x10, 0x07, 0x2a, 0x47, 0x39, 0x03, 0x06, 0x06, 0x30, 0x38, 0x0f,
0x11, 0, //Sleep Out
TFTLCD_DELAY, 150,
0x29, 0, //Display On
0x3A, 1, 0x55, //Pixel Format [66]
};
static const uint8_t ILI9341_regValues_ada[] PROGMEM = { // Adafruit_TFTLCD only works with EXTC=0
0x01, 0, // software reset
TFTLCD_DELAY, 50,
0x28, 0, //Display Off
0xC0, 1, 0x23, //Power Control 1 [26]
0xC1, 1, 0x10, //Power Control 2 [00]
0xC5, 2, 0x2B, 0x2B, //VCOM 1 [31 3C]
0xC7, 1, 0xC0, //VCOM 2 [C0]
0x36, 1, 0x88, //Memory Access [00]
0xB1, 2, 0x00, 0x1B, //Frame Control [00 1B]
0xB7, 1, 0x07, //Entry Mode [00]
0x11, 0, //Sleep Out
TFTLCD_DELAY, 150,
0x29, 0, //Display On
0x3A, 1, 0x55, //Pixel Format [66]
};
static const uint8_t ILI9341_regValues_ada9341[] PROGMEM = { // Adafruit_ILI9341
0xEF, 3, 0x03, 0x80, 0x02, //
0xCF, 3, 0x00, 0xC1, 0x30, //Power Control B [00 81 30]
0xED, 4, 0x64, 0x03, 0x12, 0x81, //Power On Seq [55 01 23 01]
0xE8, 3, 0x85, 0x00, 0x78, //Driver Timing A [04 11 7A]
0xCB, 5, 0x39, 0x2C, 0x00, 0x34, 0x02, //Power Control A [39 2C 00 34 02]
0xF7, 1, 0x20, //Pump Ratio [10]
0xEA, 2, 0x00, 0x00, //Driver Timing B [66 00]
0xC0, 1, 0x23, //Power Control 1 [26]
0xC1, 1, 0x11, //Power Control 2 [00]
0xC5, 2, 0x3E, 0x28, //VCOM 1 [31 3C]
0xC7, 1, 0x86, //VCOM 2 [C0]
0x36, 1, 0x48, //Memory Access [00]
0xB1, 2, 0x00, 0x18, //Frame Control [00 1B]
0xB6, 3, 0x0A, 0x82, 0x27, //?? Display Function [0A 82 27 XX]
0xF2, 1, 0x00, //Enable 3G [02]
0x26, 1, 0x01, //Gamma Set [01]
0xE0, 15, 0x0f, 0x31, 0x2b, 0x0c, 0x0e, 0x08, 0x4e, 0xf1, 0x37, 0x07, 0x10, 0x03, 0x0e, 0x09, 0x00,
0xE1, 15, 0x00, 0x0e, 0x14, 0x03, 0x11, 0x07, 0x31, 0xC1, 0x48, 0x08, 0x0f, 0x0c, 0x31, 0x36, 0x0f,
0x11, 0, //Sleep Out
TFTLCD_DELAY, 150,
0x29, 0, //Display On
0x3A, 1, 0x55, //Pixel Format [66]
};
// init_table(ILI9341_regValues_kbv, sizeof(ILI9341_regValues_kbv)); //ok for me
// init_table(ILI9341_regValues_2_0, sizeof(ILI9341_regValues_2_0)); //wrong direction
init_table(ILI9341_regValues_2_4, sizeof(ILI9341_regValues_2_4)); //wrong direction
// init_table(ILI9341_regValues_2_6, sizeof(ILI9341_regValues_2_6)); //inverted
// init_table(ILI9341_regValues_ada, sizeof(ILI9341_regValues_ada)); //white screen
// init_table(ILI9341_regValues_ada9341, sizeof(ILI9341_regValues_ada9341)); //ok for me
break;
case 0x9486:
_lcd_capable = AUTO_READINC | TWO_PARM_WINDOW | MV_AXIS;
static const uint8_t ILI9486_regValues[] PROGMEM = {
0x01, 0, //Soft Reset
0x28, 0, //Display Off
0xC0, 2, 0x0d, 0x0d, //Power Control 1 [0x0E0E]
0xC1, 2, 0x43, 0x00, //Power Control 2 [0x4300]
0xC2, 1, 0x00, //Power Control 3
0xC5, 4, 0x00, 0x48, 0x00, 0x48, //VCOM Control 1 [0x00400040]
0xB6, 3, 0x00, 0x22, 0x3B, // Display Function Control .kbv SS=1
// 0xE0,15, 0x0f,0x31,0x2b,0x0c,0x0e,0x08,0x4e,0xf1,0x37,0x07,0x10,0x03,0x0e,0x09,0x00,
// 0xE1,15, 0x00,0x0e,0x14,0x03,0x11,0x07,0x31,0xC1,0x48,0x08,0x0f,0x0c,0x31,0x36,0x0f,
0x20, 0, // Display Inversion OFF
0x36, 1, 0x0A, //Memory Access
0x3A, 1, 0x55, //Interlace Pixel
// 0x21, 0, //Invert display !!!
0x11, 0, //Sleep Out
TFTLCD_DELAY, 50,
0x29, 0, //Display On
};
init_table(ILI9486_regValues, sizeof(ILI9486_regValues));
p16 = (int16_t *) & HEIGHT;
*p16 = 480;
p16 = (int16_t *) & WIDTH;
*p16 = 320;
break;
case 0x9488:
_lcd_capable = AUTO_READINC | TWO_PARM_WINDOW | MV_AXIS;
static const uint8_t ILI9488_regValues[] PROGMEM = {
0x01, 0, //Soft Reset
0x28, 0, //Display Off
0xC0, 2, 0x0E, 0x0E, //Power Control 1 [0E 0E]
0xC1, 1, 0x43, //Power Control 2 [43]
0xC5, 4, 0x00, 0x22, 0x80, 0x40, //VCOM Control 1 [00 40 00 40]
0x36, 1, 0x08, //Memory Access [00]
0x3A, 1, 0x55, //Interlace Pixel [XX]
0xB1, 2, 0xB0, 0x11, //Frame Rate Control [B0 11]
0xB6, 3, 0x02, 0x02, 0x3B, //Display Function [02 02 3B] .kbv SS=0
0x11, 0, //Sleep Out
TFTLCD_DELAY, 150,
0x29, 0, //Display On
// 0x2C, 0,
};
static const uint8_t ILI9488_regValues_max[] PROGMEM = { // Atmel MaxTouch
0x01, 0, //Soft Reset
TFTLCD_DELAY, 50,
0x28, 0, //Display Off
0xC0, 2, 0x10, 0x10, //Power Control 1 [0E 0E]
0xC1, 1, 0x41, //Power Control 2 [43]
0xC5, 4, 0x00, 0x22, 0x80, 0x40, //VCOM Control 1 [00 40 00 40]
0x36, 1, 0x68, //Memory Access [00]
0xB0, 1, 0x00, //Interface [00]
0xB1, 2, 0xB0, 0x11, //Frame Rate Control [B0 11]
0xB4, 1, 0x02, //Inversion Control [02]
0xB7, 1, 0xC6, //Entry Mode [06]
0x3A, 1, 0x55, //Interlace Pixel Format [XX]
0xF7, 4, 0xA9, 0x51, 0x2C, 0x82, //Adjustment Control 3 [A9 51 2C 82]
0x11, 0, //Sleep Out
TFTLCD_DELAY, 150,
0x29, 0, //Display On
};
// init_table(ILI9488_regValues, sizeof(ILI9488_regValues));
init_table(ILI9488_regValues_max, sizeof(ILI9488_regValues_max));
p16 = (int16_t *) & HEIGHT;
*p16 = 480;
p16 = (int16_t *) & WIDTH;
*p16 = 320;
break;
// ###################################################################################
case 0x7789:
case 0x8552:
_lcd_capable = AUTO_READINC | TWO_PARM_WINDOW | MV_AXIS;
static const uint8_t ST7789_regValues[] PROGMEM = {
(0x0011); //exit SLEEP mode
TFTLCD_DELAY, 10,
(0x0036), 1, 0x80, //MADCTL: memory data access control
(0x003A), 1, 0x66, //COLMOD: Interface Pixel format *** I use 262K-colors in 18bit/pixel format when using 8-bit interface to allow 3-bytes per pixel
// (0x003A), 1, 0x0055, //COLMOD: Interface Pixel format *** I use 65K-colors in 16bit/pixel (5-6-5) format when using 16-bit interface to allow 1-byte per pixel
(0x00B2), 5, 0x0C, 0x0C, 0x00, 0x33, 0x33, //PORCTRK: Porch setting
(0x00B7), 1, 0x35, //GCTRL: Gate Control
(0x00BB), 1, 0x2B, //VCOMS: VCOM setting
(0x00C0), 1, 0x2C, //LCMCTRL: LCM Control
(0x00C2), 2, 0x01, 0xFF, //VDVVRHEN: VDV and VRH Command Enable
(0x00C3), 1, 0x11, //VRHS: VRH Set
(0x00C4), 1, 0x20, //VDVS: VDV Set
(0x00C6), 1, 0x0F, //FRCTRL2: Frame Rate control in normal mode
(0x00D0), 2, 0xA4, 0xA1, //PWCTRL1: Power Control 1
(0x00E0), 14, 0xD0, 0x00, 0x05, 0x0E, 0x15, 0x0D, 0x37, 0x43, 0x47, 0x09, 0x15, 0x12, 0x16, 0x19, //PVGAMCTRL: Positive Voltage Gamma control
(0x00E1), 14, 0xD0, 0x00, 0x05, 0x0D, 0x0C, 0x06, 0x2D, 0x44, 0x40, 0x0E, 0x1C, 0x18, 0x16, 0x19, //NVGAMCTRL: Negative Voltage Gamma control
(0x002A), 4, 0x00, 0x00, 0x00, 0xEF, //X address set
(0x002B), 4, 0x00, 0x00, 0x01, 0x3F, //Y address set
TFTLCD_DELAY, 10,
};
init_table(ST7789_regValues, sizeof(ST7789_regValues)); //
break;
// ####################################################################################
static const uint16_t ILI9225_regValues[] PROGMEM = {
/* Start Initial Sequence */
/* Set SS bit and direction output from S528 to S1 */
ILI9225_POWER_CTRL1, 0x0000, // Set SAP,DSTB,STB
ILI9225_POWER_CTRL2, 0x0000, // Set APON,PON,AON,VCI1EN,VC
ILI9225_POWER_CTRL3, 0x0000, // Set BT,DC1,DC2,DC3
ILI9225_POWER_CTRL4, 0x0000, // Set GVDD
ILI9225_POWER_CTRL5, 0x0000, // Set VCOMH/VCOML voltage
TFTLCD_DELAY, 40,
// Power-on sequence
ILI9225_POWER_CTRL2, 0x0018, // Set APON,PON,AON,VCI1EN,VC
ILI9225_POWER_CTRL3, 0x6121, // Set BT,DC1,DC2,DC3
ILI9225_POWER_CTRL4, 0x006F, // Set GVDD /*007F 0088 */
ILI9225_POWER_CTRL5, 0x495F, // Set VCOMH/VCOML voltage
ILI9225_POWER_CTRL1, 0x0800, // Set SAP,DSTB,STB
TFTLCD_DELAY, 10,
ILI9225_POWER_CTRL2, 0x103B, // Set APON,PON,AON,VCI1EN,VC
TFTLCD_DELAY, 50,
ILI9225_DRIVER_OUTPUT_CTRL, 0x011C, // set the display line number and display direction
ILI9225_LCD_AC_DRIVING_CTRL, 0x0100, // set 1 line inversion
ILI9225_ENTRY_MODE, 0x1030, // set GRAM write direction and BGR=1.
ILI9225_DISP_CTRL1, 0x0000, // Display off
ILI9225_BLANK_PERIOD_CTRL1, 0x0808, // set the back porch and front porch
ILI9225_FRAME_CYCLE_CTRL, 0x1100, // set the clocks number per line
ILI9225_INTERFACE_CTRL, 0x0000, // CPU interface
ILI9225_OSC_CTRL, 0x0D01, // Set Osc /*0e01*/
ILI9225_VCI_RECYCLING, 0x0020, // Set VCI recycling
ILI9225_RAM_ADDR_SET1, 0x0000, // RAM Address
ILI9225_RAM_ADDR_SET2, 0x0000, // RAM Address
/* Set GRAM area */
ILI9225_GATE_SCAN_CTRL, 0x0000,
ILI9225_VERTICAL_SCROLL_CTRL1, 0x00DB,
ILI9225_VERTICAL_SCROLL_CTRL2, 0x0000,
ILI9225_VERTICAL_SCROLL_CTRL3, 0x0000,
ILI9225_PARTIAL_DRIVING_POS1, 0x00DB,
ILI9225_PARTIAL_DRIVING_POS2, 0x0000,
ILI9225_HORIZONTAL_WINDOW_ADDR1, 0x00AF,
ILI9225_HORIZONTAL_WINDOW_ADDR2, 0x0000,
ILI9225_VERTICAL_WINDOW_ADDR1, 0x00DB,
ILI9225_VERTICAL_WINDOW_ADDR2, 0x0000,
/* Set GAMMA curve */
ILI9225_GAMMA_CTRL1, 0x0000,
ILI9225_GAMMA_CTRL2, 0x0808,
ILI9225_GAMMA_CTRL3, 0x080A,
ILI9225_GAMMA_CTRL4, 0x000A,
ILI9225_GAMMA_CTRL5, 0x0A08,
ILI9225_GAMMA_CTRL6, 0x0808,
ILI9225_GAMMA_CTRL7, 0x0000,
ILI9225_GAMMA_CTRL8, 0x0A00,
ILI9225_GAMMA_CTRL9, 0x0710,
ILI9225_GAMMA_CTRL10, 0x0710,
ILI9225_DISP_CTRL1, 0x0012,
TFTLCD_DELAY, 50,
ILI9225_DISP_CTRL1, 0x1017,
};
libraries/MCUFRIEND_kbv/extras/unused/OPENSMART_kbv.cpp
+20
View File
@@ -0,0 +1,20 @@
// this will avoid any library editing
//
// but the sketch must use specific OPENSMART_kbv class constructor
#define USE_SPECIAL //SPECIAL will use the first match
//#define USE_OPENSMART_SHIELD_PINOUT //deprecated
//select the target board
#define USE_OPENSMART_SHIELD_PINOUT_UNO
#define USE_OPENSMART_SHIELD_PINOUT_MEGA
#define USE_OPENSMART_SHIELD_PINOUT_DUE //thanks Michel53
//select the target controllers that are not enabled by default
#define SUPPORT_8352A //HX8352A
#define SUPPORT_8352B //HX8352B
#define SUPPORT_9225 //RM68130
#include "OPENSMART_kbv.h" //class declaration
#define MCUFRIEND_kbv OPENSMART_kbv //rename the class scope
#include "MCUFRIEND_kbv.cpp" //same methods, but with OPENSMART_kbv class scope
libraries/MCUFRIEND_kbv/extras/unused/OPENSMART_kbv.h
+78
View File
@@ -0,0 +1,78 @@
/*
* OPENSMART_kbv class inherits from Adafruit_GFX class and the Arduino Print class.
* Any use of OPENSMART_kbv class and examples is dependent on Adafruit and Arduino licenses
* The license texts are in the accompanying license.txt file
*/
#ifndef OPENSMART_KBV_H_
#define OPENSMART_KBV_H_ 101 //version number
#define MCUFRIEND_KBV_H_ OPENSMART_KBV_H_ //guard against any MCUFRIEND_kbv.h include
//#define USE_SERIAL
#if ARDUINO < 101
#define USE_GFX_KBV
#include "ADA_GFX_kbv.h"
#else
#include "Adafruit_GFX.h"
#endif
class OPENSMART_kbv : public Adafruit_GFX {
public:
// OPENSMART_kbv(int CS=A3, int RS=A2, int WR=A1, int RD=A0, int RST=A4); //shield wiring
OPENSMART_kbv(int CS=0, int RS=0, int WR=0, int RD=0, int _RST=0); //dummy arguments
void reset(void); // you only need the constructor
void begin(uint16_t ID = 0x9341); // you only need the constructor
virtual void drawPixel(int16_t x, int16_t y, uint16_t color); // and these three
void WriteCmdData(uint16_t cmd, uint16_t dat); // ?public methods !!!
void pushCommand(uint16_t cmd, uint8_t * block, int8_t N);
uint16_t color565(uint8_t r, uint8_t g, uint8_t b) { return ((r & 0xF8) << 8) | ((g & 0xFC) << 3) | ((b & 0xF8) >> 3); }
uint16_t readID(void);
virtual void fillRect(int16_t x, int16_t y, int16_t w, int16_t h, uint16_t color);
virtual void drawFastVLine(int16_t x, int16_t y, int16_t h, uint16_t color) { fillRect(x, y, 1, h, color); }
virtual void drawFastHLine(int16_t x, int16_t y, int16_t w, uint16_t color) { fillRect(x, y, w, 1, color); }
virtual void fillScreen(uint16_t color) { fillRect(0, 0, _width, _height, color); }
virtual void setRotation(uint8_t r);
virtual void invertDisplay(bool i);
uint16_t readReg(uint16_t reg, int8_t index=0);
int16_t readGRAM(int16_t x, int16_t y, uint16_t *block, int16_t w, int16_t h);
uint16_t readPixel(int16_t x, int16_t y) { uint16_t color; readGRAM(x, y, &color, 1, 1); return color; }
void setAddrWindow(int16_t x, int16_t y, int16_t x1, int16_t y1);
void pushColors(uint16_t *block, int16_t n, bool first);
void pushColors(uint8_t *block, int16_t n, bool first);
void pushColors(const uint8_t *block, int16_t n, bool first, bool bigend = false);
void vertScroll(int16_t top, int16_t scrollines, int16_t offset);
protected:
uint32_t readReg32(uint16_t reg);
uint32_t readReg40(uint16_t reg);
uint16_t _lcd_xor, _lcd_capable;
private:
uint16_t _lcd_ID, _lcd_rev, _lcd_madctl, _lcd_drivOut, _MC, _MP, _MW, _SC, _EC, _SP, _EP;
};
// New color definitions. thanks to Bodmer
#define TFT_BLACK 0x0000 /* 0, 0, 0 */
#define TFT_NAVY 0x000F /* 0, 0, 128 */
#define TFT_DARKGREEN 0x03E0 /* 0, 128, 0 */
#define TFT_DARKCYAN 0x03EF /* 0, 128, 128 */
#define TFT_MAROON 0x7800 /* 128, 0, 0 */
#define TFT_PURPLE 0x780F /* 128, 0, 128 */
#define TFT_OLIVE 0x7BE0 /* 128, 128, 0 */
#define TFT_LIGHTGREY 0xC618 /* 192, 192, 192 */
#define TFT_DARKGREY 0x7BEF /* 128, 128, 128 */
#define TFT_BLUE 0x001F /* 0, 0, 255 */
#define TFT_GREEN 0x07E0 /* 0, 255, 0 */
#define TFT_CYAN 0x07FF /* 0, 255, 255 */
#define TFT_RED 0xF800 /* 255, 0, 0 */
#define TFT_MAGENTA 0xF81F /* 255, 0, 255 */
#define TFT_YELLOW 0xFFE0 /* 255, 255, 0 */
#define TFT_WHITE 0xFFFF /* 255, 255, 255 */
#define TFT_ORANGE 0xFDA0 /* 255, 180, 0 */
#define TFT_GREENYELLOW 0xB7E0 /* 180, 255, 0 */
#define TFT_PINK 0xFC9F
#endif
libraries/MCUFRIEND_kbv/extras/unused/TFT_HX8357GLUE.h
+172
View File
@@ -0,0 +1,172 @@
// NOT FOR PUBLIC USE
#define HX8357_BLACK 0x0000
#define HX8357_BLUE 0x001F
#define HX8357_RED 0xF800
#define HX8357_GREEN 0x07E0
#define HX8357_CYAN 0x07FF
#define HX8357_MAGENTA 0xF81F
#define HX8357_YELLOW 0xFFE0
#define HX8357_WHITE 0xFFFF
//#include <Adafruit_GFX.h> // Core graphics library
#include <MCUFRIEND_kbv.h> // Hardware-specific library
#if !defined(AVR)
#include <avr/dtostrf.h>
#endif
#include <Fonts/FreeSans9pt7b.h>
#include <Fonts/FreeSans12pt7b.h>
#include <Fonts/FreeSans18pt7b.h>
#include <Fonts/FreeSerifItalic12pt7b.h>
#include <Fonts/FreeMonoBold24pt7b.h>
const GFXfont *Fonts[] = {
NULL,
NULL,
&FreeSans9pt7b,
NULL,
&FreeSans12pt7b,
NULL,
&FreeSans18pt7b,
&FreeSerifItalic12pt7b,
&FreeMonoBold24pt7b,
};
#define TFT_BLACK 0x0000
#define TFT_NAVY 0x000F
#define TFT_DARKGREEN 0x03E0
#define TFT_DARKCYAN 0x03EF
#define TFT_MAROON 0x7800
#define TFT_PURPLE 0x780F
#define TFT_OLIVE 0x7BE0
#define TFT_LIGHTGREY 0xC618
#define TFT_DARKGREY 0x7BEF
#define TFT_BLUE 0x001F
#define TFT_GREEN 0x07E0
#define TFT_CYAN 0x07FF
#define TFT_RED 0xF800
#define TFT_MAGENTA 0xF81F
#define TFT_YELLOW 0xFFE0
#define TFT_WHITE 0xFFFF
#define TFT_ORANGE 0xFD20
#define TFT_GREENYELLOW 0xAFE5
#define TFT_PINK 0xF81F
#define MC_DATUM 4
class TFT_HX8357GLUE : public MCUFRIEND_kbv
{
public:
TFT_HX8357GLUE() {}
void begin(void) {
init();
}
void init(void)
{
MCUFRIEND_kbv::reset();
_ID = MCUFRIEND_kbv::readID();
if (_ID == 0x00D3 || _ID == 0xD3D3)
_ID = 0x9486;
MCUFRIEND_kbv::begin(_ID);
MCUFRIEND_kbv::setRotation(1);
_first = true;
}
void setWindow(int16_t x0, int16_t y0, int16_t x1, int16_t y1)
{
MCUFRIEND_kbv::setAddrWindow(x0, y0, x1, y1);
_first = true;
}
void pushColors(uint8_t *data, uint16_t len)
{
MCUFRIEND_kbv::pushColors((uint8_t*)data, len, _first);
_first = false;
}
void pushColors(uint16_t *data, uint8_t len)
{
MCUFRIEND_kbv::pushColors((uint16_t*)data, len, _first);
_first = false;
}
void pushColors(uint16_t *data, uint16_t len, int first)
{
MCUFRIEND_kbv::pushColors((uint16_t*)data, len, first);
}
void pushColor(uint16_t color)
{
uint16_t c = color;
MCUFRIEND_kbv::pushColors(&c, 1, _first);
_first = false;
}
void setCursor(int16_t x, int16_t y)
{
setCursor(x, y, _font);
}
void setCursor(int16_t x, int16_t y, uint8_t idx)
{
const GFXfont *f = Fonts[idx];
MCUFRIEND_kbv::setFont(f);
// MCUFRIEND_kbv::setCursor(x, y + f->glyph->height);
MCUFRIEND_kbv::setCursor(x, y);
}
void setTextFont(uint8_t font)
{
_font = font;
MCUFRIEND_kbv::setFont(Fonts[_font]);
}
int16_t drawNumber(long long_num, int16_t poX, int16_t poY, int16_t idx)
{
char buf[12];
ltoa(long_num, buf, 10);
return drawString(buf, poX, poY, idx);
}
int16_t drawChar(char c, int16_t poX, int16_t poY, int16_t idx)
{
char buf[2];
buf[0] = c;
buf[1] = 0;
return drawString(buf, poX, poY, idx);
}
int16_t drawString(char *string, int16_t poX, int16_t poY, int16_t idx)
{
int16_t x1, y1;
uint16_t w, h;
setFont(Fonts[_font = idx]);
getTextBounds(string, poX, poY, &x1, &y1, &w, &h);
fillRect(x1, y1 + h, w, h, 0x0000);
MCUFRIEND_kbv::setCursor(poX, poY + h);
print(string);
return w;
}
int16_t drawCentreString(char *string, int16_t poX, int16_t poY, int16_t idx)
{
int16_t x1, y1;
uint16_t w, h;
setFont(Fonts[_font = idx]);
getTextBounds(string, poX, poY, &x1, &y1, &w, &h);
poX -= w/2;
x1 -= w/2;
fillRect(x1, y1 + h, w, h, 0x0000);
MCUFRIEND_kbv::setCursor(poX, poY + h);
print(string);
return w;
// return drawString(string, dX, poY, idx);
}
void setTextDatum(uint8_t datum) { ; }
void setTextPadding(uint16_t x_width) { ; }
private:
uint16_t _ID;
uint8_t _font, _first;
};
libraries/MCUFRIEND_kbv/extras/unused/appnote_himax.sed
+179
View File
@@ -0,0 +1,179 @@
#n does not work. use nsed -n
######################################################################
# nsed -f pagebreak.sed file.txt | nsed -n -f appnote_himax.sed
# copy-paste Ilitek App Note examples to xxx.txt
# ditto Renesas, Himax, ...
# or just pipe UTFT initlcd.h through
# parse Ilitek App Note sequence. e.g.
# LCD_ILI9486_CMD(0XF2);
# LCD_ILI9486_INDEX(0x18);
# Delayms(1); // Delay 1ms
# parse GalaxyCore App Note sequence. e.g.
# LCD_ GC9102_CMD(0XF2);
# LCD_ GC9102_DATA(0x18);
# delayms(1); // Delay 1ms
# parse Himax App Note sequence. e.g.
# Set_NOKIA_8B_CMD(0XF2);
# Set_NOKIA_8B_PA(0x18);
# DelayX1ms(1); // Delay 1ms
# parse Renesas App Note sequence. e.g.
# {setc, 0x000F2}
# {setp, 0x00018}
# {time, 0040,ms}
# parse UTFT sequence. e.g.
# LCD_Write_COM(0XF2);
# LCD_Write_DATA(0x18);
# delay(1); // Delay 1ms
# parse EastRising sequence. e.g.
# Write_Cmd(0XF2);
# Write_Cmd_Data(0x18);
# delayms(1); // Delay 1ms
:Ilitek
# remove leading white space
s/^[ ]*//
# //comment// to //comment
s/----\/\/$/----/
# //comment to /* comment */
s/[/][/]\((.*\)/\/\*\1\*\/ /
# change to consistent CMD syntax
s/LCD_ILI9..._CMD_INDEX/LCD_Write_COM/
s/LCD_ILI9..._CMD/LCD_Write_COM/
s/LCD_ GC9102_CMD/LCD_Write_COM/
s/r61581_cmd/LCD_Write_COM/
s/LV_DRV_DELAY_MS/delay/
s/LCD_Write_COM_DATA(\((.*\),\(.*\));/ (\11), 1, \22, /
s/IO.writeCommandTransaction/LCD_Write_COM/
s/Delayms/delay/
s/Set_NOKIA_8B_CMD/LCD_Write_COM/
s/DelayX1ms/delay/
s/Lcd_Write_Com/LCD_Write_COM/
s/lcdWriteReg(0x00/LCD_Write_COM(0x/
s/writecommand/LCD_Write_COM/
s/{setc,.* 0x000\(..\)}/LCD_Write_COM(0x\1);/
s/{time, 0*\(.*\),ms}/delay(\1);/
s/delayms/delay/
s/GUI_Delay/delay/
s/Write_Cmd_Data/LCD_Write_DATA/
s/Write_Cmd/LCD_Write_COM/
s/lcdWriteData(0x00/LCD_Write_DATA(0x/
s/LCD_WR_REG(/LCD_Write_COM(/
s/LCD_Write_COM *(/LCD_Write_COM(/
/LCD_Write_COM(/b good
/delay(/b good
b print
{
:good
h
:args
n
s/^[ ]*//
s/[ ]*\/\/[VP][0-9]+$//
s/[/][/]\(.*\)/ \/\*\1\*\/ /
s/LCD_ILI9..._CMD_PAs/LCD_Write_DATA/
s/LCD_ILI9..._INDEX/LCD_Write_DATA/
s/LCD_ILI9..._ Parameter/LCD_Write_DATA/
s/LCD_ GC9102_DATA/LCD_Write_DATA/
s/r61581_data/LCD_Write_DATA/
s/IO.writeDataTransaction/LCD_Write_DATA/
s/Set_NOKIA_8B_PA/LCD_Write_DATA/
s/DelayX1ms/delay/
s/{setp,.* 0x000\(..\)}/LCD_Write_DATA(0x\1);/
s/{setp,.* 0x00\(...\)}/LCD_Write_DATA(0x\1);/
# s/{time, 0*\(.*\),ms}/delay(\1)/
s/LCD_Write_DATA_8/LCD_Write_DATA/
s/Lcd_Write_Data/LCD_Write_DATA/
s/lcdWriteData(0x00/LCD_Write_DATA(0x/
s/writedata/LCD_Write_DATA/
s/delayms/delay/
s/Write_Cmd_Data/LCD_Write_DATA/
s/LCD_WR_DATA(/LCD_Write_DATA(/
s/LCD_Write_DATA *(/LCD_Write_DATA(/
#kludges for inconsistent syntax in Ilitek PDF
s/;)$/);/
s/)$/);/
s/;;/;/
# append any data to Hold space
/LCD_Write_DATA(/{
H
b args
}
/^$/b args
x
# parse command byte to (0xNN),
s/LCD_Write_COM(\([^)]+\)/ (\1)/
s/(0[xX]00\(..\))/(0x\1)/
# parse data byte to 0xNN,
s/\nLCD_Write_DATA(//g
# parse delay times
s/delay(\(.+\));/ TFTLCD_DELAY8, \1, /
s/)\;/,/g
s/0X/0x/g
s/0x,/0x00,/g
s/;,/,/
w 9806.out
# attempt to calculate number of parameters. show #ERROR# if > 16
/0x..),.*,.*,.*,.*,.*,.*,.*,.*,.*,.*,.*,.*,.*,.*,.*,.*,.*,/s/),/),#ERROR#,/
t counted
/0x..),.*0x..,.*0x..,.*0x..,.*0x..,.*0x..,.*0x..,.*0x..,.*0x..,.*0x..,.*0x..,.*0x..,.*0x..,.*0x..,.*0x..,.*0x..,.*0x..,/s/),/),16,/
t counted
/0x..),.*0x..,.*0x..,.*0x..,.*0x..,.*0x..,.*0x..,.*0x..,.*0x..,.*0x..,.*0x..,.*0x..,.*0x..,.*0x..,.*0x..,.*0x..,/s/),/),15,/
t counted
/0x..),.*0x..,.*0x..,.*0x..,.*0x..,.*0x..,.*0x..,.*0x..,.*0x..,.*0x..,.*0x..,.*0x..,.*0x..,.*0x..,.*0x..,/s/),/),14,/
t counted
/0x..),.*0x..,.*0x..,.*0x..,.*0x..,.*0x..,.*0x..,.*0x..,.*0x..,.*0x..,.*0x..,.*0x..,.*0x..,.*0x..,/s/),/),13,/
t counted
/0x..),.*0x..,.*0x..,.*0x..,.*0x..,.*0x..,.*0x..,.*0x..,.*0x..,.*0x..,.*0x..,.*0x..,.*0x..,/s/),/),12,/
t counted
/0x..),.*0x..,.*0x..,.*0x..,.*0x..,.*0x..,.*0x..,.*0x..,.*0x..,.*0x..,.*0x..,.*0x..,/s/),/),11,/
t counted
/0x..),.*0x..,.*0x..,.*0x..,.*0x..,.*0x..,.*0x..,.*0x..,.*0x..,.*0x..,.*0x..,/s/),/),10,/
t counted
/0x..),.*0x..,.*0x..,.*0x..,.*0x..,.*0x..,.*0x..,.*0x..,.*0x..,.*0x..,/s/),/), 9,/
t counted
/0x..),.*0x..,.*0x..,.*0x..,.*0x..,.*0x..,.*0x..,.*0x..,.*0x..,/s/),/), 8,/
t counted
/0x..),.*0x..,.*0x..,.*0x..,.*0x..,.*0x..,.*0x..,.*0x..,/s/),/), 7,/
t counted
/0x..),.*0x..,.*0x..,.*0x..,.*0x..,.*0x..,.*0x..,/s/),/), 6,/
t counted
/0x..),.*0x..,.*0x..,.*0x..,.*0x..,.*0x..,/s/),/), 5,/
t counted
/0x..),.*0x..,.*0x..,.*0x..,.*0x..,/s/),/), 4,/
t counted
/0x..),.*0x..,.*0x..,.*0x..,/s/),/), 3,/
t counted
/0x..),.*0x..,.*0x..,/s/),/), 2,/
t counted
/0x..),.*0x..,/s/),/), 1,/
t counted
/0x..),/s/),/), 0,/
:counted
# life is simpler with multiple whitespace reduced to single space
s/[ ]+/ /g
s/ $//
#/(0x2C)/p
# attempt to move first comment to end of line
s/\((0x..),[ 1][0-9],\) \/\*\([^*]*\)\*\/ \(.*\)/\1 \3 \/\/\2/
#s/\((0x..),[ 1][0-9],\) \(\/\*[^*]*\*\/\) \(.*\)/\1 \3 \2/
#/0x..),[ 1][0-9],/s/ *\(\/\*[^*]*\*\/\) *\(.*\)/ \2 \1/
p
x
b Ilitek
}
:print
s/^[Vv]oid \(.*\)_Initial.*(void)/const unsigned char \1[] =/
s/^void LCD_Initial_\(.*\)(void)/const unsigned char \1[] =/
s/^void \(.*\)::init()/const unsigned char \1[] =/
s/^}$/};/
p
:end
libraries/MCUFRIEND_kbv/extras/unused/graphictest_opensmart/graphictest_opensmart.ino
+586
View File
@@ -0,0 +1,586 @@
// All the mcufriend.com UNO shields have the same pinout.
// i.e. control pins A0-A4. Data D2-D9. microSD D10-D13.
// Touchscreens are normally A1, A2, D7, D6 but the order varies
//
// This demo should work with most Adafruit TFT libraries
// If you are not using a shield, use a full Adafruit constructor()
// e.g. Adafruit_TFTLCD tft(LCD_CS, LCD_CD, LCD_WR, LCD_RD, LCD_RESET);
#define LCD_CS A3 // Chip Select goes to Analog 3
#define LCD_CD A2 // Command/Data goes to Analog 2
#define LCD_WR A1 // LCD Write goes to Analog 1
#define LCD_RD A0 // LCD Read goes to Analog 0
#define LCD_RESET A4 // Can alternately just connect to Arduino's reset pin
#include <SPI.h> // f.k. for Arduino-1.5.2
#include "Adafruit_GFX.h"// Hardware-specific library
#include <OPENSMART_kbv.h>
OPENSMART_kbv tft;
//#include <Adafruit_TFTLCD.h>
//Adafruit_TFTLCD tft(LCD_CS, LCD_CD, LCD_WR, LCD_RD, LCD_RESET);
// Assign human-readable names to some common 16-bit color values:
#define BLACK 0x0000
#define BLUE 0x001F
#define RED 0xF800
#define GREEN 0x07E0
#define CYAN 0x07FF
#define MAGENTA 0xF81F
#define YELLOW 0xFFE0
#define WHITE 0xFFFF
#ifndef min
#define min(a, b) (((a) < (b)) ? (a) : (b))
#endif
void setup(void);
void loop(void);
unsigned long testFillScreen();
unsigned long testText();
unsigned long testLines(uint16_t color);
unsigned long testFastLines(uint16_t color1, uint16_t color2);
unsigned long testRects(uint16_t color);
unsigned long testFilledRects(uint16_t color1, uint16_t color2);
unsigned long testFilledCircles(uint8_t radius, uint16_t color);
unsigned long testCircles(uint8_t radius, uint16_t color);
unsigned long testTriangles();
unsigned long testFilledTriangles();
unsigned long testRoundRects();
unsigned long testFilledRoundRects();
void progmemPrint(const char *str);
void progmemPrintln(const char *str);
void runtests(void);
uint16_t g_identifier;
extern const uint8_t hanzi[];
void showhanzi(unsigned int x, unsigned int y, unsigned char index)
{
uint8_t i, j, c, first = 1;
uint8_t *temp = (uint8_t*)hanzi;
uint16_t color;
tft.setAddrWindow(x, y, x + 31, y + 31); //设置区域
temp += index * 128;
for (j = 0; j < 128; j++)
{
c = pgm_read_byte(temp);
for (i = 0; i < 8; i++)
{
if ((c & (1 << i)) != 0)
{
color = RED;
}
else
{
color = BLACK;
}
tft.pushColors(&color, 1, first);
first = 0;
}
temp++;
}
}
void setup(void) {
Serial.begin(9600);
uint32_t when = millis();
// while (!Serial) ; //hangs a Leonardo until you connect a Serial
if (!Serial) delay(5000); //allow some time for Leonardo
Serial.println("Serial took " + String((millis() - when)) + "ms to start");
// tft.reset(); //hardware reset
uint16_t ID = tft.readID(); //
Serial.print("ID = 0x");
Serial.println(ID, HEX);
if (ID == 0xD3D3) ID = 0x9481; // write-only shield
// ID = 0x9329; // force ID
tft.begin(ID);
}
#if defined(MCUFRIEND_KBV_H_)
uint16_t scrollbuf[320]; // my biggest screen is 320x480
#define READGRAM(x, y, buf, w, h) tft.readGRAM(x, y, buf, w, h)
#else
uint16_t scrollbuf[320]; // Adafruit only does 240x320
// Adafruit can read a block by one pixel at a time
int16_t READGRAM(int16_t x, int16_t y, uint16_t *block, int16_t w, int16_t h)
{
uint16_t *p;
for (int row = 0; row < h; row++) {
p = block + row * w;
for (int col = 0; col < w; col++) {
*p++ = tft.readPixel(x + col, y + row);
}
}
}
#endif
void windowScroll(int16_t x, int16_t y, int16_t wid, int16_t ht, int16_t dx, int16_t dy, uint16_t *buf)
{
if (dx) for (int16_t row = 0; row < ht; row++) {
READGRAM(x, y + row, buf, wid, 1);
tft.setAddrWindow(x, y + row, x + wid - 1, y + row);
tft.pushColors(buf + dx, wid - dx, 1);
tft.pushColors(buf + 0, dx, 0);
}
if (dy) for (int16_t col = 0; col < wid; col++) {
READGRAM(x + col, y, buf, 1, ht);
tft.setAddrWindow(x + col, y, x + col, y + ht - 1);
tft.pushColors(buf + dy, ht - dy, 1);
tft.pushColors(buf + 0, dy, 0);
}
}
void printmsg(int row, const char *msg)
{
tft.setTextColor(YELLOW, BLACK);
tft.setCursor(0, row);
tft.println(msg);
}
void loop(void) {
uint8_t aspect;
uint16_t pixel;
const char *aspectname[] = {
"PORTRAIT", "LANDSCAPE", "PORTRAIT_REV", "LANDSCAPE_REV"
};
const char *colorname[] = { "BLUE", "GREEN", "RED", "GRAY" };
uint16_t colormask[] = { 0x001F, 0x07E0, 0xF800, 0xFFFF };
uint16_t dx, rgb, n, wid, ht, msglin;
tft.setRotation(0);
runtests();
delay(2000);
if (tft.height() > 64) {
for (uint8_t cnt = 0; cnt < 4; cnt++) {
aspect = (cnt + 0) & 3;
tft.setRotation(aspect);
wid = tft.width();
ht = tft.height();
msglin = (ht > 160) ? 200 : 112;
testText();
dx = wid / 32;
for (n = 0; n < 32; n++) {
rgb = n * 8;
rgb = tft.color565(rgb, rgb, rgb);
tft.fillRect(n * dx, 48, dx, 63, rgb & colormask[aspect]);
}
tft.drawRect(0, 48 + 63, wid, 1, WHITE);
tft.setTextSize(2);
tft.setTextColor(colormask[aspect], BLACK);
tft.setCursor(0, 72);
tft.print(colorname[aspect]);
tft.setTextColor(WHITE);
tft.println(" COLOR GRADES");
tft.setTextColor(WHITE, BLACK);
printmsg(184, aspectname[aspect]);
delay(1000);
tft.drawPixel(0, 0, YELLOW);
pixel = tft.readPixel(0, 0);
tft.setTextSize((ht > 160) ? 2 : 1); //for messages
#if defined(MCUFRIEND_KBV_H_)
#if 1
extern const uint8_t penguin[];
tft.setAddrWindow(wid - 40 - 40, 20 + 0, wid - 1 - 40, 20 + 39);
tft.pushColors(penguin, 1600, 1);
#elif 1
extern const uint8_t wifi_full[];
tft.setAddrWindow(wid - 40 - 40, 20 + 0, wid - 40 - 40 + 31, 20 + 31);
tft.pushColors(wifi_full, 1024, 1, true);
#elif 1
extern const uint8_t icon_40x40[];
tft.setAddrWindow(wid - 40 - 40, 20 + 0, wid - 1 - 40, 20 + 39);
tft.pushColors(icon_40x40, 1600, 1);
#endif
tft.setAddrWindow(0, 0, wid - 1, ht - 1);
if (aspect & 1) tft.drawRect(wid - 1, 0, 1, ht, WHITE);
else tft.drawRect(0, ht - 1, wid, 1, WHITE);
printmsg(msglin, "VERTICAL SCROLL UP");
uint16_t maxscroll;
if (tft.getRotation() & 1) maxscroll = wid;
else maxscroll = ht;
for (uint16_t i = 1; i <= maxscroll; i++) {
tft.vertScroll(0, maxscroll, i);
delay(10);
}
delay(1000);
printmsg(msglin, "VERTICAL SCROLL DN");
for (uint16_t i = 1; i <= maxscroll; i++) {
tft.vertScroll(0, maxscroll, 0 - (int16_t)i);
delay(10);
}
tft.vertScroll(0, maxscroll, 0);
printmsg(msglin, "SCROLL DISABLED ");
delay(1000);
if ((aspect & 1) == 0) { //Portrait
tft.setTextColor(BLUE, BLACK);
printmsg(msglin, "ONLY THE COLOR BAND");
for (uint16_t i = 1; i <= 64; i++) {
tft.vertScroll(48, 64, i);
delay(20);
}
delay(1000);
}
#endif
tft.setTextColor(YELLOW, BLACK);
if (pixel == YELLOW) {
printmsg(msglin, "SOFTWARE SCROLL ");
#if 0
// diagonal scroll of block
for (int16_t i = 45, dx = 2, dy = 1; i > 0; i -= dx) {
windowScroll(24, 8, 90, 40, dx, dy, scrollbuf);
}
#else
// plain horizontal scroll of block
n = (wid > 320) ? 320 : wid;
for (int16_t i = n, dx = 4, dy = 0; i > 0; i -= dx) {
windowScroll(0, 200, n, 16, dx, dy, scrollbuf);
}
#endif
}
else if (pixel == CYAN)
tft.println("readPixel() reads as BGR");
else if ((pixel & 0xF8F8) == 0xF8F8)
tft.println("readPixel() should be 24-bit");
else {
tft.print("readPixel() reads 0x");
tft.println(pixel, HEX);
}
delay(5000);
}
}
printmsg(msglin, "INVERT DISPLAY ");
tft.invertDisplay(true);
delay(2000);
tft.invertDisplay(false);
}
typedef struct {
PGM_P msg;
uint32_t ms;
} TEST;
TEST result[12];
#define RUNTEST(n, str, test) { result[n].msg = PSTR(str); result[n].ms = test; delay(500); }
void runtests(void)
{
uint8_t i, len = 24, cnt;
uint32_t total;
RUNTEST(0, "FillScreen ", testFillScreen());
RUNTEST(1, "Text ", testText());
RUNTEST(2, "Lines ", testLines(CYAN));
RUNTEST(3, "Horiz/Vert Lines ", testFastLines(RED, BLUE));
RUNTEST(4, "Rectangles (outline) ", testRects(GREEN));
RUNTEST(5, "Rectangles (filled) ", testFilledRects(YELLOW, MAGENTA));
RUNTEST(6, "Circles (filled) ", testFilledCircles(10, MAGENTA));
RUNTEST(7, "Circles (outline) ", testCircles(10, WHITE));
RUNTEST(8, "Triangles (outline) ", testTriangles());
RUNTEST(9, "Triangles (filled) ", testFilledTriangles());
RUNTEST(10, "Rounded rects (outline) ", testRoundRects());
RUNTEST(11, "Rounded rects (filled) ", testFilledRoundRects());
tft.fillScreen(BLACK);
tft.setTextColor(GREEN);
tft.setCursor(0, 0);
uint16_t wid = tft.width();
if (wid > 176) {
tft.setTextSize(2);
#if defined(MCUFRIEND_KBV_H_)
tft.print("MCUFRIEND ");
#if MCUFRIEND_KBV_H_ != 0
tft.print(0.01 * MCUFRIEND_KBV_H_, 2);
#else
tft.print("for");
#endif
tft.println(" UNO");
#else
tft.println("Adafruit-Style Tests");
#endif
} else len = wid / 6 - 8;
tft.setTextSize(1);
total = 0;
for (i = 0; i < 12; i++) {
PGM_P str = result[i].msg;
char c;
if (len > 24) {
if (i < 10) tft.print(" ");
tft.print(i);
tft.print(": ");
}
uint8_t cnt = len;
while ((c = pgm_read_byte(str++)) && cnt--) tft.print(c);
tft.print(" ");
tft.println(result[i].ms);
total += result[i].ms;
}
tft.setTextSize(2);
tft.print("Total:");
tft.print(0.000001 * total);
tft.println("sec");
g_identifier = tft.readID();
tft.print("ID: 0x");
tft.println(tft.readID(), HEX);
// tft.print("Reg(00):0x");
// tft.println(tft.readReg(0x00), HEX);
tft.print("F_CPU:");
tft.print(0.000001 * F_CPU);
#if defined(__OPTIMIZE_SIZE__)
tft.println("MHz -Os");
#else
tft.println("MHz");
#endif
delay(10000);
}
// Standard Adafruit tests. will adjust to screen size
unsigned long testFillScreen() {
unsigned long start = micros();
tft.fillScreen(BLACK);
tft.fillScreen(RED);
tft.fillScreen(GREEN);
tft.fillScreen(BLUE);
tft.fillScreen(BLACK);
return micros() - start;
}
unsigned long testText() {
unsigned long start;
tft.fillScreen(BLACK);
start = micros();
tft.setCursor(0, 0);
tft.setTextColor(WHITE); tft.setTextSize(1);
tft.println("Hello World!");
tft.setTextColor(YELLOW); tft.setTextSize(2);
tft.println(123.45);
tft.setTextColor(RED); tft.setTextSize(3);
tft.println(0xDEADBEEF, HEX);
tft.println();
tft.setTextColor(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(BLACK);
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
tft.fillScreen(BLACK);
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;
tft.fillScreen(BLACK);
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;
tft.fillScreen(BLACK);
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);
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(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(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(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);
}
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(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(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(0, 0, 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(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, i));
t += micros() - start;
tft.drawTriangle(cx, cy - i, cx - i, cy + i, cx + i, cy + i,
tft.color565(i, i, 0));
}
return t;
}
unsigned long testRoundRects() {
unsigned long start;
int w, i, i2, red, step,
cx = tft.width() / 2 - 1,
cy = tft.height() / 2 - 1;
tft.fillScreen(BLACK);
w = min(tft.width(), tft.height());
start = micros();
red = 0;
step = (256 * 6) / w;
for (i = 0; i < w; i += 6) {
i2 = i / 2;
red += step;
tft.drawRoundRect(cx - i2, cy - i2, i, i, i / 8, tft.color565(red, 0, 0));
}
return micros() - start;
}
unsigned long testFilledRoundRects() {
unsigned long start;
int i, i2, green, step,
cx = tft.width() / 2 - 1,
cy = tft.height() / 2 - 1;
tft.fillScreen(BLACK);
start = micros();
green = 256;
step = (256 * 6) / min(tft.width(), tft.height());
for (i = min(tft.width(), tft.height()); i > 20; i -= 6) {
i2 = i / 2;
green -= step;
tft.fillRoundRect(cx - i2, cy - i2, i, i, i / 8, tft.color565(0, green, 0));
}
return micros() - start;
}
libraries/MCUFRIEND_kbv/extras/unused/graphictest_opensmart/icons.c
+542
View File
@@ -0,0 +1,542 @@
#if defined(__arm__) || defined(ESP8266) || defined(ESP32)
#define PROGMEM
#else
#include <Arduino.h>
#endif
const unsigned char PROGMEM penguin[3200] = { /* 0X00,0X10,0X28,0X00,0X28,0X00,0X01,0X1B, */
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XBE, 0XF7, 0X7D, 0XEF,
0XBA, 0XD6, 0XB6, 0XB5, 0XF3, 0X9C, 0XB2, 0X94, 0XB3, 0X9C, 0XB2, 0X94, 0X34, 0XA5, 0XF7, 0XBD,
0XFB, 0XDE, 0X7D, 0XEF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XBE, 0XF7, 0XFB, 0XDE, 0XF3, 0X9C, 0XCB, 0X5A,
0XC7, 0X39, 0X04, 0X21, 0X82, 0X10, 0X42, 0X10, 0X42, 0X10, 0X41, 0X08, 0X83, 0X18, 0X45, 0X29,
0XC7, 0X39, 0X0C, 0X63, 0X75, 0XAD, 0X3C, 0XE7, 0XBE, 0XF7, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0X3C, 0XE7, 0XB2, 0X94, 0X08, 0X42, 0XC3, 0X18, 0X82, 0X10,
0X04, 0X21, 0X45, 0X29, 0X86, 0X31, 0X86, 0X31, 0X86, 0X31, 0X86, 0X31, 0X45, 0X29, 0X04, 0X21,
0X82, 0X10, 0X41, 0X08, 0XC3, 0X18, 0X08, 0X42, 0XF3, 0X9C, 0X3C, 0XE7, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFB, 0XDE, 0X0C, 0X63, 0XC3, 0X18, 0XC3, 0X18, 0X45, 0X29, 0XC7, 0X39,
0X08, 0X42, 0X08, 0X42, 0X08, 0X42, 0X08, 0X42, 0X08, 0X42, 0X08, 0X42, 0XC7, 0X39, 0XC7, 0X39,
0X86, 0X31, 0X86, 0X31, 0X04, 0X21, 0X41, 0X08, 0X82, 0X10, 0XCB, 0X5A, 0XBA, 0XD6, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFB, 0XDE, 0XCB, 0X5A, 0X82, 0X10, 0X45, 0X29, 0XC7, 0X39, 0X08, 0X42, 0X08, 0X42,
0X09, 0X4A, 0X49, 0X4A, 0X49, 0X4A, 0X49, 0X4A, 0X49, 0X4A, 0X49, 0X4A, 0X08, 0X42, 0XC7, 0X39,
0XC7, 0X39, 0XC7, 0X39, 0X86, 0X31, 0X45, 0X29, 0X83, 0X18, 0X00, 0X00, 0XC8, 0X41, 0X38, 0XC6,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0X7D, 0XEF, 0X8E, 0X73, 0X82, 0X10, 0X45, 0X29, 0XC7, 0X39, 0X08, 0X42, 0X09, 0X4A, 0X8A, 0X52,
0X30, 0X84, 0XCF, 0X7B, 0X8A, 0X52, 0X49, 0X4A, 0X4A, 0X52, 0X49, 0X4A, 0XCB, 0X5A, 0XCF, 0X7B,
0X0C, 0X63, 0X08, 0X42, 0XC7, 0X39, 0X86, 0X31, 0X45, 0X29, 0XC3, 0X18, 0X00, 0X00, 0X49, 0X4A,
0XBA, 0XD6, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XF3, 0X9C, 0XC3, 0X18, 0X04, 0X21, 0XC7, 0X39, 0X08, 0X42, 0X49, 0X4A, 0X49, 0X4A, 0X72, 0X94,
0X7D, 0XEF, 0X7D, 0XEF, 0XB2, 0X94, 0X4A, 0X52, 0X49, 0X4A, 0X8A, 0X52, 0X75, 0XAD, 0XBE, 0XF7,
0XBA, 0XD6, 0X4D, 0X6B, 0XC7, 0X39, 0XC7, 0X39, 0X86, 0X31, 0X45, 0X29, 0XC3, 0X18, 0X41, 0X08,
0XCF, 0X7B, 0X7C, 0XE7, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XBA, 0XD6,
0X08, 0X42, 0X82, 0X10, 0XC7, 0X39, 0X08, 0X42, 0X49, 0X4A, 0X49, 0X4A, 0X8E, 0X73, 0XFB, 0XDE,
0XFF, 0XFF, 0XBE, 0XF7, 0XBA, 0XD6, 0X8E, 0X73, 0X08, 0X42, 0X30, 0X84, 0X3C, 0XE7, 0X7D, 0XEF,
0XFF, 0XFF, 0XB6, 0XB5, 0X49, 0X4A, 0XC7, 0X39, 0X86, 0X31, 0X45, 0X29, 0X04, 0X21, 0X41, 0X08,
0X45, 0X29, 0XB6, 0XB5, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XBE, 0XF7, 0X71, 0X8C,
0X41, 0X08, 0X45, 0X29, 0X08, 0X42, 0X49, 0X4A, 0X49, 0X4A, 0X4A, 0X52, 0XB2, 0X94, 0XBE, 0XF7,
0XBE, 0XF7, 0XB2, 0X94, 0XCF, 0X7B, 0XCF, 0X7B, 0X49, 0X4A, 0XB6, 0XB5, 0XF3, 0X9C, 0X0C, 0X63,
0X38, 0XC6, 0XBA, 0XD6, 0X0C, 0X63, 0X87, 0X39, 0XC7, 0X39, 0X86, 0X31, 0X45, 0X29, 0XC3, 0X18,
0X41, 0X08, 0X30, 0X84, 0X7D, 0XEF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0X3C, 0XE7, 0XCB, 0X5A,
0X41, 0X08, 0XC7, 0X39, 0X08, 0X42, 0X49, 0X4A, 0X4A, 0X52, 0X8A, 0X52, 0XF3, 0X9C, 0XFF, 0XFF,
0X7D, 0XEF, 0XC7, 0X39, 0XC3, 0X18, 0X0C, 0X63, 0XCB, 0X5A, 0XB6, 0XB5, 0XB2, 0X94, 0XCB, 0X5A,
0X75, 0XAD, 0XFA, 0XD6, 0X4D, 0X6B, 0X87, 0X39, 0XC7, 0X39, 0X86, 0X31, 0X45, 0X29, 0X04, 0X21,
0X41, 0X08, 0X8A, 0X52, 0X79, 0XCE, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0X38, 0XC6, 0X86, 0X31,
0X04, 0X21, 0XC8, 0X41, 0X49, 0X4A, 0X49, 0X4A, 0X4A, 0X52, 0X49, 0X4A, 0XB1, 0X8C, 0XBE, 0XF7,
0XBE, 0XF7, 0XB2, 0X94, 0XCF, 0X7B, 0XCF, 0X7B, 0X49, 0X4A, 0X74, 0XA5, 0X7D, 0XEF, 0X7C, 0XE7,
0XBE, 0XF7, 0X79, 0XCE, 0X0C, 0X63, 0XC7, 0X39, 0XC7, 0X39, 0X86, 0X31, 0X45, 0X29, 0X04, 0X21,
0X82, 0X10, 0X45, 0X29, 0X75, 0XAD, 0XBE, 0XF7, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0X34, 0XA5, 0X82, 0X10,
0X86, 0X31, 0X08, 0X42, 0X49, 0X4A, 0X49, 0X4A, 0X8A, 0X52, 0X49, 0X4A, 0X4D, 0X6B, 0XBA, 0XD6,
0XFF, 0XFF, 0XFF, 0XFF, 0X79, 0XCE, 0X0D, 0X63, 0XC7, 0X39, 0XCF, 0X7B, 0X7D, 0XEF, 0XFF, 0XFF,
0XFF, 0XFF, 0X75, 0XAD, 0X08, 0X42, 0X86, 0X31, 0XC7, 0X39, 0X86, 0X31, 0X45, 0X29, 0X45, 0X29,
0XC3, 0X18, 0XC3, 0X18, 0XB2, 0X94, 0X7D, 0XEF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XBE, 0XF7, 0XB2, 0X8C, 0X41, 0X08,
0XC7, 0X39, 0X08, 0X42, 0X49, 0X4A, 0X49, 0X4A, 0X8A, 0X52, 0X8A, 0X52, 0X4A, 0X4A, 0XD0, 0X7B,
0X7A, 0XC6, 0X7B, 0XBE, 0X90, 0X6B, 0XC9, 0X39, 0X88, 0X31, 0XC9, 0X39, 0XB3, 0X84, 0XBB, 0XC6,
0XF8, 0XB5, 0XCC, 0X5A, 0X86, 0X31, 0XC7, 0X39, 0XC7, 0X39, 0X86, 0X31, 0X45, 0X29, 0X45, 0X29,
0XC4, 0X20, 0X41, 0X08, 0X30, 0X84, 0X3C, 0XE7, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0X3C, 0XE7, 0X8A, 0X4A, 0XC3, 0X10,
0XC7, 0X39, 0X08, 0X42, 0X49, 0X4A, 0X49, 0X4A, 0X4A, 0X4A, 0X4A, 0X42, 0X09, 0X3A, 0X08, 0X4A,
0X09, 0X6B, 0X49, 0X7B, 0XC6, 0X7A, 0X05, 0X83, 0X46, 0X83, 0XC5, 0X7A, 0XC6, 0X72, 0X09, 0X7B,
0X48, 0X5A, 0X87, 0X31, 0X88, 0X21, 0X88, 0X29, 0X86, 0X31, 0X86, 0X31, 0X45, 0X29, 0X45, 0X29,
0X04, 0X21, 0X41, 0X08, 0X4A, 0X4A, 0XBA, 0XD6, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XF7, 0XC5, 0X82, 0X50, 0X05, 0X41,
0XC7, 0X29, 0X08, 0X42, 0X49, 0X4A, 0X4A, 0X42, 0X49, 0X4A, 0X09, 0X7B, 0X88, 0X9B, 0XC6, 0XB3,
0X21, 0XD4, 0XA0, 0XDC, 0XE1, 0XE4, 0X61, 0XED, 0X61, 0XED, 0X21, 0XED, 0XA0, 0XE4, 0X20, 0XDC,
0X80, 0XCB, 0X43, 0XAB, 0XC4, 0X82, 0X06, 0X5A, 0X47, 0X21, 0X46, 0X29, 0X45, 0X29, 0X04, 0X29,
0X04, 0X19, 0X82, 0X10, 0X82, 0X18, 0XF3, 0X9C, 0X7D, 0XEF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0X7D, 0XEF, 0X4D, 0X93, 0X00, 0XA0, 0X82, 0XB8,
0XC7, 0X31, 0X09, 0X32, 0X49, 0X4A, 0X86, 0X7A, 0X43, 0XC3, 0X6B, 0XED, 0XF4, 0XF6, 0XEB, 0XFD,
0X20, 0XFD, 0X20, 0XFD, 0X60, 0XFD, 0XA0, 0XFD, 0XA0, 0XFD, 0X60, 0XFD, 0X60, 0XFD, 0X20, 0XFD,
0XE0, 0XFC, 0XA0, 0XFC, 0X60, 0XF4, 0XC1, 0XDB, 0X83, 0X9A, 0XC5, 0X49, 0X45, 0X29, 0X04, 0X19,
0XC4, 0X20, 0X82, 0X38, 0X00, 0X50, 0XCB, 0X6A, 0XBA, 0XD6, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFB, 0XEE, 0X04, 0XA1, 0X00, 0XC0, 0X00, 0XF0,
0XC3, 0XA0, 0XC8, 0X41, 0X49, 0X42, 0X05, 0X9B, 0X20, 0XFC, 0XA4, 0XFC, 0X69, 0XFD, 0XE8, 0XFD,
0X63, 0XFD, 0X20, 0XFD, 0X60, 0XFD, 0X60, 0XFD, 0X60, 0XFD, 0X20, 0XFD, 0X20, 0XFD, 0XE0, 0XFC,
0XE0, 0XFC, 0XA0, 0XFC, 0X60, 0XFC, 0X20, 0XFC, 0X41, 0XD3, 0XC5, 0X49, 0X45, 0X19, 0XC4, 0X38,
0X82, 0X68, 0X41, 0X88, 0X00, 0X70, 0X49, 0X5A, 0X79, 0XCE, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFB, 0XF6, 0X82, 0XC0, 0X00, 0XD0, 0X86, 0XC1,
0X46, 0XF1, 0X41, 0XC8, 0X45, 0X79, 0X89, 0X52, 0X88, 0X62, 0X86, 0X6A, 0XC6, 0X7A, 0XC4, 0XBB,
0XE1, 0XFC, 0X60, 0XFD, 0X60, 0XFD, 0XA0, 0XFD, 0XA0, 0XFD, 0X60, 0XFD, 0X60, 0XFD, 0XE0, 0XFC,
0X60, 0XE4, 0X03, 0X93, 0X84, 0X72, 0X44, 0X6A, 0XC5, 0X41, 0X45, 0X29, 0XC3, 0X58, 0X41, 0XA8,
0X40, 0X98, 0X00, 0XB0, 0X00, 0X60, 0X0C, 0X6B, 0X79, 0XCE, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0X7D, 0XEF, 0XCE, 0X83, 0X82, 0X88, 0X00, 0XF8, 0XC4, 0XD8,
0X0C, 0XF3, 0X8A, 0XFA, 0X82, 0XE8, 0X82, 0XB0, 0X45, 0X69, 0XC7, 0X51, 0X08, 0X42, 0X08, 0X3A,
0X86, 0X5A, 0X83, 0X9B, 0XA2, 0XBC, 0X22, 0XCD, 0X21, 0XCD, 0XA1, 0XC4, 0X22, 0XB4, 0XC4, 0X7A,
0X06, 0X3A, 0X86, 0X29, 0X45, 0X29, 0X05, 0X31, 0XC4, 0X50, 0X41, 0X90, 0X00, 0XC0, 0X00, 0XA8,
0X00, 0XA0, 0X00, 0XA8, 0X00, 0X30, 0X4A, 0X4A, 0XBA, 0XD6, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0X7D, 0XEF, 0X8E, 0X73, 0XC3, 0X18, 0X05, 0X39, 0X82, 0XA8, 0X00, 0XF8,
0XC3, 0XF8, 0X4D, 0XFB, 0X4D, 0XFB, 0XC7, 0XF9, 0XC3, 0XF0, 0X82, 0XD8, 0XC3, 0XB0, 0X04, 0X81,
0X45, 0X61, 0X46, 0X51, 0X86, 0X49, 0X86, 0X49, 0X46, 0X41, 0X45, 0X41, 0X45, 0X41, 0X45, 0X41,
0X05, 0X49, 0X04, 0X61, 0X82, 0X90, 0X41, 0XB0, 0X00, 0XD0, 0X00, 0XC8, 0X00, 0XA8, 0X00, 0XA8,
0X00, 0XB8, 0X41, 0X58, 0X82, 0X10, 0X82, 0X10, 0XB2, 0X94, 0XBE, 0XF7, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XBE, 0XF7, 0XCF, 0X7B, 0X82, 0X10, 0X04, 0X21, 0X86, 0X29, 0X86, 0X41, 0X04, 0X99,
0X40, 0XE8, 0X41, 0XF8, 0X86, 0XF9, 0XCB, 0XFA, 0X49, 0XFA, 0X82, 0XF8, 0X00, 0XF8, 0X00, 0XF0,
0X00, 0XE8, 0X41, 0XD8, 0X41, 0XD0, 0X41, 0XC0, 0X41, 0XC0, 0X41, 0XC0, 0X41, 0XC0, 0X41, 0XC8,
0X00, 0XD0, 0X00, 0XE0, 0X00, 0XE0, 0X00, 0XD8, 0X00, 0XD0, 0X00, 0XB8, 0X00, 0XA8, 0X41, 0X88,
0X82, 0X48, 0X82, 0X10, 0X82, 0X10, 0X00, 0X00, 0X45, 0X29, 0X79, 0XCE, 0XFF, 0XFF, 0XFF, 0XFF,
0XBE, 0XF7, 0XF3, 0X9C, 0X82, 0X10, 0XC3, 0X18, 0X45, 0X29, 0X86, 0X31, 0XC7, 0X31, 0X30, 0X7C,
0XF3, 0XDC, 0X86, 0XE1, 0X00, 0XF0, 0X00, 0XF8, 0X41, 0XF8, 0X41, 0XF8, 0X00, 0XF8, 0X00, 0XF8,
0X00, 0XF8, 0X00, 0XF8, 0X00, 0XF8, 0X00, 0XF8, 0X00, 0XF8, 0X00, 0XF8, 0X00, 0XF8, 0X00, 0XF8,
0X00, 0XE8, 0X00, 0XE0, 0X00, 0XE0, 0X00, 0XD8, 0X00, 0XC8, 0X41, 0XA0, 0X8A, 0X9A, 0X0C, 0X63,
0X04, 0X11, 0X82, 0X10, 0X82, 0X10, 0X41, 0X08, 0X00, 0X00, 0X4D, 0X6B, 0X7D, 0XEF, 0XFF, 0XFF,
0XFB, 0XDE, 0X08, 0X42, 0X42, 0X10, 0X45, 0X29, 0X86, 0X31, 0X86, 0X31, 0X49, 0X4A, 0X38, 0XBE,
0XFF, 0XFF, 0X38, 0XD6, 0X86, 0XA9, 0X00, 0XC8, 0X00, 0XE0, 0X00, 0XF0, 0X00, 0XF8, 0X00, 0XF8,
0X00, 0XF8, 0X00, 0XF8, 0X00, 0XF8, 0X00, 0XF8, 0X00, 0XF8, 0X00, 0XF8, 0X00, 0XF0, 0X00, 0XF0,
0X00, 0XE8, 0X00, 0XE0, 0X00, 0XD0, 0XC3, 0X98, 0X8A, 0X8A, 0XB2, 0XA4, 0XBA, 0XC6, 0XF7, 0XB5,
0X08, 0X42, 0X41, 0X08, 0X82, 0X10, 0X41, 0X08, 0X00, 0X00, 0X45, 0X29, 0XF7, 0XBD, 0XFF, 0XFF,
0X71, 0X8C, 0X41, 0X08, 0X04, 0X21, 0X45, 0X29, 0X86, 0X31, 0X86, 0X31, 0X0C, 0X63, 0X3C, 0XE7,
0XFF, 0XFF, 0X79, 0XD6, 0X46, 0XB9, 0X00, 0XE0, 0X42, 0XC8, 0X82, 0XA8, 0X82, 0XB0, 0X41, 0XD8,
0X82, 0XE8, 0X82, 0XF0, 0X41, 0XE8, 0X41, 0XE8, 0X41, 0XE8, 0X41, 0XF0, 0X41, 0XE8, 0X41, 0XD8,
0X04, 0XC1, 0X08, 0X92, 0X4D, 0X8B, 0X34, 0XA5, 0XFB, 0XC6, 0XFB, 0XD6, 0XBA, 0XCE, 0X3C, 0XE7,
0X30, 0X84, 0XC3, 0X18, 0X41, 0X08, 0X41, 0X08, 0X00, 0X00, 0X41, 0X08, 0XCF, 0X7B, 0X7D, 0XEF,
0X49, 0X4A, 0X00, 0X00, 0X04, 0X21, 0X45, 0X29, 0X46, 0X31, 0X86, 0X31, 0X30, 0X84, 0XFF, 0XFF,
0XFF, 0XF7, 0XF7, 0XDD, 0X09, 0XDA, 0X83, 0XF8, 0X01, 0XF0, 0X42, 0XC0, 0X82, 0X98, 0X49, 0X9A,
0XF3, 0XB4, 0XF3, 0XCC, 0X71, 0XBC, 0X8E, 0XBB, 0X8E, 0XBB, 0X30, 0XBC, 0X71, 0XBC, 0XF3, 0XBC,
0XB6, 0XBD, 0XFB, 0XCE, 0XBE, 0XE7, 0X7D, 0XE7, 0X3B, 0XDF, 0XBA, 0XD6, 0X79, 0XCE, 0XFB, 0XDE,
0X75, 0XAD, 0X86, 0X31, 0X41, 0X08, 0X41, 0X08, 0X00, 0X00, 0X00, 0X00, 0X49, 0X4A, 0XFB, 0XDE,
0X04, 0X21, 0X41, 0X08, 0X04, 0X21, 0X45, 0X29, 0X45, 0X29, 0X87, 0X39, 0XB2, 0X94, 0XFF, 0XFF,
0XBE, 0XF7, 0X34, 0XDD, 0X0C, 0XEB, 0X09, 0XFA, 0X00, 0XF0, 0X01, 0XD8, 0X00, 0XD8, 0X8B, 0XD2,
0X7D, 0XE7, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XBE, 0XFF, 0X7D, 0XEF, 0XFB, 0XDE, 0XFB, 0XDE, 0XBA, 0XD6, 0X79, 0XCE, 0XBA, 0XD6,
0X78, 0XC6, 0XC7, 0X39, 0X00, 0X00, 0X41, 0X08, 0X00, 0X00, 0X00, 0X00, 0XC7, 0X39, 0X79, 0XCE,
0X00, 0X00, 0X82, 0X10, 0XC3, 0X18, 0X04, 0X21, 0X05, 0X29, 0X86, 0X31, 0XB3, 0X9C, 0XFF, 0XFF,
0XFF, 0XF7, 0X75, 0XDD, 0XC7, 0XE9, 0XC7, 0XF9, 0X01, 0XF8, 0X01, 0XF0, 0X00, 0XE8, 0X49, 0XE2,
0XFB, 0XEE, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XBE, 0XF7, 0X7D, 0XEF, 0XFB, 0XDE, 0XFB, 0XDE, 0XBA, 0XD6, 0X79, 0XCE, 0XBA, 0XD6,
0XB9, 0XCE, 0X08, 0X42, 0X00, 0X00, 0X00, 0X00, 0X00, 0X00, 0X00, 0X00, 0XC7, 0X39, 0X38, 0XC6,
0X00, 0X00, 0X82, 0X10, 0X82, 0X10, 0X04, 0X21, 0X04, 0X21, 0X45, 0X29, 0X30, 0X84, 0XFF, 0XFF,
0XFF, 0XFF, 0X38, 0XDE, 0XC4, 0XD0, 0X00, 0XF0, 0X01, 0XF8, 0X00, 0XF8, 0X00, 0XF0, 0X08, 0XD2,
0XFB, 0XE6, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XBE, 0XF7, 0X7D, 0XEF, 0XFB, 0XDE, 0XBA, 0XD6, 0X79, 0XCE, 0X79, 0XCE, 0XBA, 0XD6,
0X79, 0XCE, 0XC7, 0X39, 0X41, 0X08, 0X00, 0X00, 0X00, 0X00, 0X00, 0X00, 0X86, 0X31, 0X38, 0XC6,
0X00, 0X00, 0X00, 0X00, 0XC3, 0X18, 0XCB, 0X5A, 0X86, 0X31, 0XC3, 0X18, 0XCB, 0X5A, 0X7D, 0XEF,
0XFF, 0XFF, 0X7D, 0XEF, 0XCF, 0XBB, 0XC3, 0XB0, 0X41, 0XD0, 0X41, 0XD0, 0X82, 0XB8, 0X4D, 0XB3,
0X7D, 0XE7, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XBE, 0XF7, 0XBE, 0XF7, 0X3D, 0XEF, 0XFB, 0XDE, 0XBA, 0XD6, 0X79, 0XCE, 0X79, 0XCE, 0XFA, 0XD6,
0XF7, 0XBD, 0X04, 0X21, 0X86, 0X31, 0X04, 0X21, 0X00, 0X00, 0X00, 0X00, 0X86, 0X31, 0X38, 0XC6,
0X86, 0X31, 0XC3, 0X18, 0XCB, 0X5A, 0X75, 0XAD, 0XCF, 0X7B, 0X41, 0X08, 0X86, 0X31, 0XF7, 0XBD,
0XFF, 0XFF, 0XFF, 0XFF, 0XBE, 0XEF, 0X74, 0XB5, 0X30, 0X9C, 0X30, 0X9C, 0X72, 0XA4, 0XBB, 0XD6,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XBE, 0XF7, 0X7D, 0XEF, 0X3C, 0XE7, 0XFB, 0XDE, 0XBA, 0XD6, 0X79, 0XCE, 0X79, 0XCE, 0X3C, 0XE7,
0X71, 0X8C, 0X81, 0X08, 0X0C, 0X63, 0XCF, 0X7B, 0X82, 0X10, 0X00, 0X00, 0X8A, 0X52, 0X38, 0XC6,
0X75, 0XAD, 0X71, 0X8C, 0XB6, 0XB5, 0X3C, 0XE7, 0XFB, 0XDE, 0XC7, 0X39, 0X00, 0X00, 0XCF, 0X73,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XBE, 0XF7,
0X7D, 0XEF, 0X7D, 0XEF, 0X3B, 0XDF, 0XFA, 0XD6, 0X79, 0XCE, 0X79, 0XCE, 0XFB, 0XDE, 0XB9, 0XCE,
0XC7, 0X39, 0XC4, 0X20, 0X71, 0X8C, 0XBA, 0XD6, 0X71, 0X8C, 0XCB, 0X5A, 0XB2, 0X94, 0XBA, 0XD6,
0XFF, 0XFF, 0X7D, 0XEF, 0X7D, 0XEF, 0XFF, 0XFF, 0XFF, 0XFF, 0XB6, 0XB5, 0X46, 0X29, 0X05, 0X19,
0X75, 0XA5, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XBE, 0XF7,
0X7D, 0XEF, 0X3C, 0XE7, 0XFB, 0XDE, 0XBA, 0XD6, 0X79, 0XCE, 0XBA, 0XD6, 0XFC, 0XDE, 0X4E, 0X63,
0X42, 0X08, 0X0C, 0X63, 0XF7, 0XBD, 0XBE, 0XF7, 0XFF, 0XFF, 0XFB, 0XDE, 0XFB, 0XDE, 0XBE, 0XF7,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XF4, 0X9C, 0X04, 0X21,
0X05, 0X21, 0XB6, 0XA5, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XBE, 0XF7, 0XBE, 0XF7, 0X7D, 0XEF,
0X3C, 0XE7, 0XFB, 0XDE, 0XBA, 0XD6, 0X79, 0XCE, 0XFB, 0XDE, 0XBB, 0XD6, 0XD1, 0X73, 0X83, 0X18,
0X86, 0X39, 0X34, 0X9D, 0XBD, 0XEF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XBE, 0XFF, 0X35, 0XD6, 0XEB, 0XCC, 0X43, 0XB3,
0X40, 0X51, 0X05, 0X19, 0XF5, 0X8C, 0XBE, 0XEF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XBE, 0XF7, 0XBE, 0XF7, 0X7D, 0XEF, 0X7D, 0XEF, 0X3C, 0XE7,
0XFB, 0XDE, 0XBA, 0XDE, 0XBA, 0XD6, 0X3C, 0XDF, 0X3A, 0XBE, 0X4F, 0X63, 0X82, 0X49, 0X40, 0XA3,
0X23, 0XB4, 0XCC, 0X83, 0X3A, 0XBE, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XBF, 0XF7, 0XB5, 0XBD, 0X82, 0X92, 0X20, 0XF4, 0XA0, 0XFC,
0X60, 0XE4, 0X40, 0X82, 0X84, 0X41, 0X8F, 0X6B, 0X77, 0XAD, 0X3D, 0XE7, 0XFF, 0XFF, 0XFF, 0XFF,
0XFE, 0XFF, 0XBE, 0XF7, 0XBE, 0XF7, 0XBE, 0XF7, 0X7D, 0XEF, 0X7D, 0XEF, 0X3C, 0XE7, 0XFB, 0XDE,
0XFB, 0XDE, 0X3D, 0XE7, 0XBB, 0XCE, 0X36, 0X9D, 0X0B, 0X6B, 0X41, 0X6A, 0X60, 0XC4, 0X20, 0XFE,
0X60, 0XF5, 0X00, 0X8B, 0XC7, 0X6A, 0X38, 0XC6, 0XBE, 0XF7, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0X7D, 0XEF, 0X4B, 0X7B, 0X80, 0XB2, 0XA0, 0XFC, 0XA0, 0XFC,
0XE0, 0XFC, 0XE0, 0XFC, 0XC0, 0XCB, 0XC1, 0X8A, 0X45, 0X62, 0X4D, 0X6B, 0XB3, 0X94, 0XF7, 0XBD,
0X3D, 0XDF, 0XFF, 0XF7, 0XFF, 0XFF, 0XBE, 0XF7, 0X7D, 0XEF, 0X7D, 0XEF, 0X7D, 0XE7, 0X3D, 0XDF,
0XBA, 0XC6, 0X75, 0XA5, 0X8D, 0X7B, 0X84, 0X7A, 0X40, 0XB3, 0XE0, 0XEC, 0XE0, 0XFD, 0XE0, 0XFD,
0X60, 0XF5, 0X20, 0XE5, 0XA0, 0XD4, 0X0A, 0X6B, 0XFB, 0XDE, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0X7D, 0XEF, 0XCC, 0X93, 0X40, 0XEB, 0X60, 0XFC, 0XA0, 0XFC,
0XE0, 0XFC, 0X20, 0XFD, 0X60, 0XFD, 0X20, 0XF5, 0XA0, 0XD4, 0XC0, 0XBB, 0X42, 0X9B, 0X45, 0X8B,
0X6B, 0X9C, 0XAE, 0X9C, 0X71, 0X8C, 0XB3, 0X94, 0X33, 0X9D, 0X34, 0XA5, 0XF2, 0XA4, 0XF0, 0XB4,
0XCA, 0X9B, 0X04, 0X9B, 0X40, 0XBB, 0X20, 0XE4, 0X20, 0XFD, 0XA0, 0XFD, 0XA0, 0XFD, 0XE0, 0XFD,
0XE0, 0XFD, 0XE0, 0XFD, 0X20, 0XC4, 0X88, 0X5A, 0X38, 0XBE, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0X78, 0XD6, 0X46, 0XAB, 0X40, 0XDB, 0X20, 0XF4,
0X60, 0XFC, 0XA0, 0XFC, 0XE0, 0XFC, 0X60, 0XFD, 0XA0, 0XFD, 0X60, 0XFD, 0X20, 0XF5, 0XA0, 0XDC,
0XC0, 0XB3, 0XC0, 0X51, 0X86, 0X29, 0X0D, 0X63, 0X8F, 0X7B, 0X0D, 0X5B, 0XC7, 0X41, 0X01, 0X82,
0X00, 0XC3, 0XC0, 0XE3, 0X60, 0XFC, 0XA0, 0XFC, 0XE0, 0XFC, 0XE0, 0XFC, 0X60, 0XF5, 0X60, 0XF5,
0X20, 0XE5, 0X80, 0X9B, 0X86, 0X62, 0X30, 0X84, 0X79, 0XCE, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0X38, 0XC6, 0X2D, 0X9C, 0X05, 0X93,
0X43, 0XA3, 0X82, 0XB3, 0XC2, 0XBB, 0XC2, 0XBB, 0X22, 0XB4, 0X82, 0XA3, 0X42, 0X93, 0XC3, 0X7A,
0X85, 0X62, 0X0B, 0X63, 0X71, 0X84, 0XB6, 0XB5, 0X79, 0XCE, 0X79, 0XC6, 0XB5, 0XAD, 0X70, 0X94,
0X4A, 0X8B, 0X06, 0X83, 0X04, 0X93, 0X04, 0X9B, 0X43, 0X9B, 0X43, 0X9B, 0X43, 0X93, 0X04, 0X83,
0X08, 0X73, 0X8D, 0X73, 0XB3, 0X94, 0X79, 0XCE, 0X7D, 0XEF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0X3C, 0XDF, 0X38, 0XBE,
0X75, 0XB5, 0X33, 0XA5, 0X33, 0XA5, 0XF3, 0X9C, 0XF3, 0X9C, 0XF3, 0X9C, 0XF3, 0X94, 0XF3, 0X9C,
0X35, 0XA5, 0XF8, 0XBD, 0XFB, 0XDE, 0XBE, 0XF7, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0X7E, 0XEF,
0XBB, 0XD6, 0XF8, 0XBD, 0XB6, 0XAD, 0X75, 0XAD, 0X34, 0XA5, 0X33, 0X9D, 0X34, 0X9D, 0X35, 0XA5,
0XB7, 0XAD, 0X79, 0XC6, 0X3C, 0XE7, 0XBE, 0XF7, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
};
const unsigned char PROGMEM icon_40x40[3200] = { /* 0X00,0X10,0X28,0X00,0X28,0X00,0X01,0X1B, */
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0X5D, 0XEF, 0X71, 0X8C, 0X31, 0X84, 0X31, 0X84,
0X93, 0XC5, 0X92, 0XCD, 0X91, 0XCD, 0X91, 0XD5, 0X91, 0XD5, 0X91, 0XCD, 0X72, 0XCD, 0X72, 0XC5,
0X56, 0XDE, 0XBE, 0XFF, 0XDB, 0XDE, 0XFB, 0XDE, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XCE, 0X7B, 0X00, 0X00, 0X00, 0X00, 0X00, 0X00,
0X00, 0X5A, 0X20, 0XDD, 0X20, 0XDD, 0X20, 0XDD, 0X20, 0XDD, 0X20, 0XDD, 0XE0, 0XD4, 0XA0, 0XD4,
0X61, 0XA3, 0XA7, 0X39, 0XE5, 0X18, 0X05, 0X21, 0X92, 0X94, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XF9, 0XEE, 0XEB, 0X9B, 0XA1, 0X18, 0X23, 0X73, 0X81, 0XC5, 0X21, 0X9C,
0X61, 0X39, 0X81, 0XEE, 0X40, 0XFF, 0XE0, 0XFE, 0XE0, 0XFE, 0XE0, 0XFE, 0X40, 0XFF, 0XC0, 0XF6,
0XC0, 0X49, 0XA0, 0X18, 0X00, 0X42, 0X60, 0X18, 0X00, 0X00, 0X74, 0XB5, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0X93, 0XCD, 0XC3, 0XBB, 0XA0, 0X51, 0XE1, 0X39, 0XC2, 0XFF, 0XE0, 0XFF, 0XE0, 0XFF,
0X63, 0XBD, 0X61, 0XE6, 0X40, 0XFF, 0XE0, 0XFE, 0XE0, 0XFE, 0XC0, 0XFE, 0X60, 0XFF, 0X21, 0X73,
0XE1, 0X28, 0X81, 0XEE, 0X61, 0XFF, 0X21, 0XEE, 0XA0, 0X41, 0X20, 0X08, 0X90, 0XCD, 0XDE, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0X5C, 0XF7,
0X0B, 0XAC, 0XC0, 0XB3, 0XA1, 0XEE, 0XC3, 0X5A, 0X22, 0X8C, 0XE1, 0XFF, 0X40, 0XFF, 0X40, 0XFF,
0XC0, 0XFF, 0X80, 0XFF, 0X20, 0XFF, 0X20, 0XFF, 0X20, 0XFF, 0X00, 0XFF, 0X20, 0XFF, 0XA1, 0XAC,
0X21, 0XC5, 0X20, 0XFF, 0X60, 0XFE, 0X00, 0XFF, 0X02, 0XDE, 0XE0, 0X20, 0X40, 0X82, 0X49, 0XBC,
0X3B, 0XEF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0X5C, 0XF7, 0X67, 0X9B,
0XE0, 0XB3, 0X81, 0XFF, 0XC3, 0XFF, 0X83, 0X9C, 0X82, 0XDE, 0XC0, 0XFF, 0X60, 0XFF, 0X60, 0XFF,
0X40, 0XFF, 0X60, 0XFF, 0X40, 0XFF, 0X40, 0XFF, 0X40, 0XFF, 0X20, 0XFF, 0X00, 0XFF, 0X60, 0XFF,
0X40, 0XFF, 0XA0, 0XFE, 0X80, 0XFE, 0X40, 0XFE, 0XE0, 0XFE, 0XA2, 0XB4, 0X41, 0XBC, 0X20, 0XCC,
0X87, 0XA3, 0XB8, 0XE6, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0X9D, 0XF7, 0XA8, 0XA3, 0X60, 0XBC,
0XA2, 0XFF, 0XA5, 0XFF, 0X44, 0XFF, 0XA1, 0XFF, 0XA0, 0XFF, 0X60, 0XFF, 0X80, 0XFF, 0X80, 0XFF,
0X80, 0XFF, 0X80, 0XFF, 0X60, 0XFF, 0X60, 0XFF, 0X40, 0XFF, 0X40, 0XFF, 0X20, 0XFF, 0X20, 0XFF,
0X00, 0XFF, 0XC0, 0XFE, 0XA0, 0XFE, 0X80, 0XFE, 0X40, 0XFE, 0X60, 0XFE, 0X20, 0XFE, 0X40, 0XFE,
0XE0, 0XCB, 0XE3, 0X92, 0X7C, 0XF7, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0X4C, 0XAC, 0XC0, 0XB3, 0XA4, 0XFF,
0XA6, 0XFF, 0X45, 0XFF, 0X62, 0XFF, 0X80, 0XFF, 0X80, 0XFF, 0X80, 0XFF, 0XA0, 0XFF, 0XA0, 0XFF,
0XA0, 0XFF, 0XA0, 0XFF, 0X80, 0XFF, 0X80, 0XFF, 0X80, 0XFF, 0X60, 0XFF, 0X40, 0XFF, 0X40, 0XFF,
0X20, 0XFF, 0XE0, 0XFE, 0XC0, 0XFE, 0X80, 0XFE, 0X60, 0XFE, 0X40, 0XFE, 0X20, 0XFE, 0X00, 0XFE,
0XE0, 0XFD, 0XE0, 0XC3, 0X2A, 0XAC, 0X7D, 0XF7, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XD4, 0XD5, 0X40, 0XAB, 0X43, 0XFF, 0XA8, 0XFF,
0X67, 0XFF, 0X62, 0XFF, 0X80, 0XFF, 0X80, 0XFF, 0XA0, 0XFF, 0XA0, 0XFF, 0XC0, 0XFF, 0XC0, 0XFF,
0XC0, 0XFF, 0XA0, 0XFF, 0XA0, 0XFF, 0XA0, 0XFF, 0X80, 0XFF, 0X80, 0XFF, 0X60, 0XFF, 0X40, 0XFF,
0X40, 0XFF, 0X00, 0XFF, 0XE0, 0XFE, 0XA0, 0XFE, 0X80, 0XFE, 0X40, 0XFE, 0X20, 0XFE, 0XE0, 0XFD,
0XE0, 0XFD, 0XC0, 0XFD, 0XA0, 0XA2, 0X11, 0XBD, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XDA, 0XE6, 0XE4, 0X9A, 0XE1, 0XE5, 0XE8, 0XFF, 0X69, 0XFF,
0X65, 0XFF, 0X60, 0XFF, 0X80, 0XFF, 0XA0, 0XFF, 0XC0, 0XFF, 0XE0, 0XFF, 0XE0, 0XFF, 0XE0, 0XFF,
0XE0, 0XFF, 0XC0, 0XFF, 0XC0, 0XFF, 0XA0, 0XFF, 0XA0, 0XFF, 0X80, 0XFF, 0X80, 0XFF, 0X60, 0XFF,
0X40, 0XFF, 0X00, 0XFF, 0X00, 0XFF, 0X20, 0XFF, 0XE0, 0XFE, 0X60, 0XFE, 0X20, 0XFE, 0X00, 0XFE,
0XC0, 0XFD, 0XE0, 0XFD, 0XE0, 0XE4, 0X85, 0XAB, 0XFA, 0XE6, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0X2B, 0XB4, 0XC0, 0XB3, 0XC8, 0XFF, 0X8C, 0XFF, 0X68, 0XFF,
0X61, 0XFF, 0XA0, 0XFF, 0XA0, 0XFF, 0XC0, 0XFF, 0XE0, 0XFF, 0XE1, 0XFF, 0XA1, 0XDE, 0X61, 0XEF,
0XE1, 0XFF, 0XE0, 0XFF, 0XE0, 0XFF, 0XC0, 0XFF, 0XC0, 0XFF, 0XA0, 0XFF, 0X80, 0XFF, 0X60, 0XFF,
0X40, 0XFF, 0X60, 0XFF, 0XC0, 0XFF, 0X61, 0XDE, 0X00, 0XE6, 0X80, 0XFE, 0X40, 0XFE, 0X00, 0XFE,
0XE0, 0XFD, 0XC0, 0XFD, 0XE0, 0XFD, 0XC0, 0XC3, 0XE9, 0XAB, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0X5D, 0XEF, 0XA3, 0XAB, 0XA3, 0XF6, 0XCC, 0XFF, 0X4C, 0XFF, 0X64, 0XFF,
0X80, 0XFF, 0XA0, 0XFF, 0XC0, 0XFF, 0XE0, 0XFF, 0X61, 0XEF, 0X22, 0X6B, 0X82, 0X5A, 0X82, 0XB5,
0XE2, 0XFF, 0XE1, 0XFF, 0XE0, 0XFF, 0XE0, 0XFF, 0XE0, 0XFF, 0XA0, 0XFF, 0X80, 0XFF, 0X60, 0XFF,
0XA0, 0XFF, 0XE1, 0XFF, 0X42, 0X8C, 0XC1, 0X41, 0X21, 0XA4, 0XA0, 0XFE, 0X80, 0XFE, 0X20, 0XFE,
0XE0, 0XFD, 0XC0, 0XFD, 0XA0, 0XFD, 0X20, 0XF5, 0XC0, 0X9A, 0X35, 0XD6, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0X51, 0XC5, 0X60, 0XBC, 0XC9, 0XFF, 0X8E, 0XFF, 0X6A, 0XFF, 0X61, 0XFF,
0X80, 0XFF, 0XA0, 0XFF, 0XC0, 0XFF, 0XE1, 0XFF, 0XE1, 0X62, 0X80, 0X10, 0X05, 0XE7, 0XA4, 0XF7,
0XE4, 0XFF, 0XE3, 0XFF, 0XE2, 0XFF, 0XE0, 0XFF, 0XE0, 0XFF, 0XC0, 0XFF, 0XA0, 0XFF, 0XA0, 0XFF,
0XC1, 0XFF, 0XE2, 0X83, 0X40, 0X08, 0X22, 0XCE, 0X60, 0XF7, 0XA0, 0XFE, 0X60, 0XFE, 0X20, 0XFE,
0XE0, 0XFD, 0XC0, 0XFD, 0X80, 0XFD, 0XA0, 0XFD, 0XA0, 0XC3, 0XAC, 0XBC, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XDE, 0XFF, 0XA7, 0XAB, 0X81, 0XDD, 0XED, 0XFF, 0XB0, 0XFF, 0X69, 0XFF, 0X60, 0XFF,
0X80, 0XFF, 0XA0, 0XFF, 0XE0, 0XFF, 0X61, 0XD6, 0X22, 0X29, 0XA6, 0X31, 0XE3, 0X7B, 0X46, 0XEF,
0XE6, 0XFF, 0XE4, 0XFF, 0XE2, 0XFF, 0XE1, 0XFF, 0XE0, 0XFF, 0XC0, 0XFF, 0XA0, 0XFF, 0XE0, 0XFF,
0X81, 0XD6, 0XA0, 0X18, 0XC4, 0X18, 0XA1, 0X62, 0XC1, 0XCD, 0X40, 0XFF, 0X60, 0XFE, 0X20, 0XFE,
0XE0, 0XFD, 0XC0, 0XFD, 0X80, 0XFD, 0X80, 0XFD, 0XA0, 0XEC, 0X48, 0XBC, 0XDF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XF9, 0XE6, 0XE3, 0X9A, 0X67, 0XEE, 0XD1, 0XFF, 0XB0, 0XFF, 0X86, 0XFF, 0X60, 0XFF,
0X80, 0XFF, 0XA0, 0XFF, 0XE0, 0XFF, 0X60, 0X94, 0X91, 0X73, 0XD9, 0XBD, 0X00, 0X00, 0X05, 0X84,
0XE8, 0XFF, 0XE5, 0XFF, 0XE3, 0XFF, 0XE1, 0XFF, 0XE0, 0XFF, 0XC0, 0XFF, 0XA0, 0XFF, 0XE0, 0XFF,
0X20, 0XAD, 0XE9, 0X41, 0XB7, 0XB5, 0X01, 0X00, 0X60, 0X62, 0X21, 0XFF, 0X80, 0XFE, 0X20, 0XFE,
0XE0, 0XFD, 0XC0, 0XFD, 0X80, 0XFD, 0X60, 0XFD, 0X20, 0XF5, 0XE3, 0XBB, 0XD9, 0XE6, 0XFF, 0XFF,
0XFF, 0XFF, 0XD3, 0XCD, 0X40, 0XA3, 0X2B, 0XF7, 0XD3, 0XFF, 0XB0, 0XFF, 0X63, 0XFF, 0X60, 0XFF,
0X80, 0XFF, 0XA0, 0XFF, 0XE0, 0XFF, 0XA0, 0X9C, 0X30, 0X6B, 0X97, 0XB5, 0X00, 0X00, 0X83, 0X52,
0XC6, 0XFF, 0XE5, 0XFF, 0XE3, 0XFF, 0XE1, 0XFF, 0XE0, 0XFF, 0XC0, 0XFF, 0XA0, 0XFF, 0XE0, 0XFF,
0X20, 0XAD, 0XEA, 0X41, 0X77, 0XAD, 0X01, 0X00, 0XC0, 0X49, 0XE0, 0XF6, 0XA0, 0XFE, 0X20, 0XFE,
0XE0, 0XFD, 0XC0, 0XFD, 0X80, 0XFD, 0X60, 0XFD, 0X40, 0XFD, 0XA0, 0XBB, 0XD3, 0XCD, 0XFF, 0XFF,
0XFF, 0XFF, 0X50, 0XCD, 0X00, 0XB4, 0X8E, 0XFF, 0XF4, 0XFF, 0XB0, 0XFF, 0X42, 0XFF, 0X60, 0XFF,
0X80, 0XFF, 0XA0, 0XFF, 0XE0, 0XFF, 0XA1, 0XDE, 0X01, 0X21, 0X00, 0X00, 0X00, 0X00, 0X25, 0X8C,
0XE5, 0XFF, 0XE3, 0XFF, 0XE2, 0XFF, 0XE0, 0XFF, 0XE0, 0XFF, 0XC0, 0XFF, 0XA0, 0XFF, 0XE0, 0XFF,
0XE1, 0XDE, 0X01, 0X21, 0X00, 0X00, 0X00, 0X00, 0X61, 0X5A, 0X20, 0XFF, 0X80, 0XFE, 0X20, 0XFE,
0X00, 0XFE, 0XE0, 0XFD, 0XA0, 0XFD, 0X60, 0XFD, 0X60, 0XFD, 0XC0, 0XCB, 0X71, 0XCD, 0XFF, 0XFF,
0XFF, 0XFF, 0X50, 0XCD, 0X40, 0XC4, 0XB0, 0XFF, 0XF5, 0XFF, 0X8F, 0XFF, 0X41, 0XFF, 0X80, 0XFF,
0XA0, 0XFF, 0XC0, 0XFF, 0XE0, 0XFF, 0XE1, 0XFF, 0X21, 0X8C, 0X60, 0X10, 0X43, 0X6B, 0X44, 0XEF,
0XE2, 0XFF, 0XE2, 0XFF, 0XE1, 0XFF, 0XE0, 0XFF, 0XC0, 0XFF, 0XA0, 0XFF, 0X80, 0XFF, 0X80, 0XFF,
0XE1, 0XFF, 0XC1, 0XA4, 0XC2, 0X18, 0XA2, 0X39, 0XA1, 0XCD, 0X20, 0XFF, 0X60, 0XFE, 0X20, 0XFE,
0XC0, 0XFD, 0X80, 0XFD, 0X80, 0XFD, 0X60, 0XFD, 0X60, 0XFD, 0XE0, 0XCB, 0X91, 0XCD, 0XFF, 0XFF,
0XFF, 0XFF, 0X50, 0XCD, 0X40, 0XC4, 0XD2, 0XFF, 0XF7, 0XFF, 0XAF, 0XFF, 0X01, 0XFF, 0X00, 0XFF,
0X00, 0XFF, 0X40, 0XFF, 0XA0, 0XFF, 0XE0, 0XFF, 0XA1, 0XFF, 0X82, 0XD6, 0XC2, 0XFF, 0XE0, 0XFF,
0XE0, 0XFF, 0XE0, 0XFF, 0XE0, 0XFF, 0XC0, 0XFF, 0XC0, 0XFF, 0XA0, 0XFF, 0X80, 0XFF, 0X60, 0XFF,
0X60, 0XFF, 0XC1, 0XFF, 0X82, 0XDE, 0XC2, 0XEE, 0X61, 0XFF, 0X80, 0XFE, 0XC0, 0XFD, 0X20, 0XFD,
0XA1, 0XFC, 0X61, 0XFC, 0X61, 0XFC, 0XC0, 0XFC, 0X60, 0XFD, 0XE0, 0XCB, 0X51, 0XC5, 0XFF, 0XFF,
0XFF, 0XFF, 0X50, 0XCD, 0X60, 0XC4, 0XD4, 0XFF, 0XF9, 0XFF, 0X2D, 0XFF, 0X00, 0XFE, 0XC0, 0XFD,
0XA1, 0XFD, 0X21, 0XFE, 0XE0, 0XFE, 0XC0, 0XFF, 0XE0, 0XFF, 0XE0, 0XFF, 0XE0, 0XFF, 0XE0, 0XFF,
0XE0, 0XFF, 0XE0, 0XFF, 0XC0, 0XFF, 0XC0, 0XFF, 0XA0, 0XFF, 0X80, 0XFF, 0X80, 0XFF, 0X60, 0XFF,
0X40, 0XFF, 0X40, 0XFF, 0X80, 0XFF, 0X20, 0XFF, 0XA0, 0XFE, 0X20, 0XFE, 0X01, 0XFD, 0X01, 0XFC,
0X62, 0XFB, 0X42, 0XFB, 0X82, 0XFB, 0X21, 0XFC, 0X20, 0XFD, 0X00, 0XD4, 0X71, 0XC5, 0XFF, 0XFF,
0XFF, 0XFF, 0X50, 0XCD, 0X20, 0XC4, 0XD4, 0XFF, 0XBA, 0XFF, 0X2E, 0XFE, 0XE1, 0XFC, 0X61, 0XFC,
0X61, 0XFC, 0X01, 0XFD, 0X01, 0XFE, 0X20, 0XFF, 0XA0, 0XFF, 0XA0, 0XFF, 0XC0, 0XFF, 0XC0, 0XFF,
0XC0, 0XFF, 0XC0, 0XFF, 0XA0, 0XFF, 0XA0, 0XFF, 0X80, 0XFF, 0X80, 0XFF, 0X60, 0XFF, 0X40, 0XFF,
0X40, 0XFF, 0X00, 0XFF, 0XC0, 0XFE, 0XA0, 0XFE, 0X80, 0XFE, 0X80, 0XFD, 0X61, 0XFC, 0X62, 0XFB,
0XA3, 0XFA, 0XA3, 0XFA, 0X42, 0XFB, 0X01, 0XFC, 0XE0, 0XFC, 0XE0, 0XCB, 0X71, 0XCD, 0XFF, 0XFF,
0XFF, 0XFF, 0X50, 0XCD, 0XC0, 0XB3, 0XB3, 0XFF, 0X7A, 0XFF, 0X91, 0XFD, 0X03, 0XFC, 0X02, 0XFB,
0X22, 0XFB, 0X62, 0XFC, 0X81, 0XFD, 0XC0, 0XFE, 0XA0, 0XFF, 0XA0, 0XFF, 0XA0, 0XFF, 0XA0, 0XFF,
0XA0, 0XFF, 0XA0, 0XFF, 0X80, 0XFF, 0X80, 0XFF, 0X60, 0XFF, 0X60, 0XFF, 0X40, 0XFF, 0X40, 0XFF,
0X20, 0XFF, 0XE0, 0XFE, 0XC0, 0XFE, 0XA0, 0XFE, 0X60, 0XFE, 0X60, 0XFD, 0X41, 0XFC, 0X62, 0XFB,
0XC3, 0XFA, 0XA3, 0XFA, 0X42, 0XFB, 0X01, 0XFC, 0X20, 0XFD, 0XC0, 0XCB, 0X91, 0XCD, 0XFF, 0XFF,
0XFF, 0XFF, 0X14, 0XD6, 0X20, 0XAB, 0X51, 0XF7, 0XBE, 0XFF, 0X17, 0XFE, 0X65, 0XFC, 0X61, 0XFB,
0XA2, 0XFB, 0XA1, 0XFC, 0XC1, 0XFD, 0X00, 0XFF, 0X80, 0XFF, 0X80, 0XFF, 0X80, 0XFF, 0X80, 0XFF,
0X80, 0XFF, 0X80, 0XFF, 0X80, 0XFF, 0X60, 0XFF, 0X60, 0XFF, 0X60, 0XFF, 0X40, 0XFF, 0X20, 0XFF,
0X00, 0XFF, 0XC0, 0XFE, 0XA0, 0XFE, 0X80, 0XFE, 0X60, 0XFE, 0XC0, 0XFD, 0XC0, 0XFC, 0X41, 0XFC,
0XC1, 0XFB, 0XA2, 0XFB, 0X01, 0XFC, 0XA0, 0XFC, 0X40, 0XFD, 0XA0, 0XC3, 0XF4, 0XD5, 0XFF, 0XFF,
0XFF, 0XFF, 0X5B, 0XEF, 0X24, 0X9B, 0X49, 0XE6, 0XB8, 0XFF, 0X92, 0XFE, 0X25, 0XFD, 0XA0, 0XFC,
0X02, 0XFD, 0XE1, 0XFD, 0XE0, 0XFE, 0X40, 0XFF, 0X60, 0XFF, 0X40, 0XFF, 0X60, 0XFF, 0X60, 0XFF,
0X60, 0XFF, 0X60, 0XFF, 0X40, 0XFF, 0X40, 0XFF, 0X40, 0XFF, 0X40, 0XFF, 0X20, 0XFF, 0X00, 0XFF,
0XC0, 0XFE, 0XA0, 0XFE, 0X80, 0XFE, 0X40, 0XFE, 0X40, 0XFE, 0X00, 0XFE, 0X80, 0XFD, 0X01, 0XF5,
0X41, 0XFD, 0X01, 0XFD, 0XC0, 0XFC, 0X40, 0XFD, 0X00, 0XF5, 0XC4, 0XBB, 0XFA, 0XE6, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0X2A, 0XB4, 0XA0, 0XD4, 0XA2, 0XFE, 0X20, 0XFE, 0XE0, 0XFD, 0X00, 0XFE,
0X80, 0XFE, 0X21, 0XEE, 0X41, 0XE6, 0X40, 0XFF, 0X40, 0XFF, 0X40, 0XFF, 0X40, 0XFF, 0X40, 0XFF,
0X40, 0XFF, 0X40, 0XFF, 0X40, 0XFF, 0X20, 0XFF, 0X20, 0XFF, 0X00, 0XFF, 0XE0, 0XFE, 0XC0, 0XFE,
0XA0, 0XFE, 0X80, 0XFE, 0X60, 0XFE, 0X40, 0XFE, 0X00, 0XFE, 0X00, 0XFE, 0X00, 0XFE, 0X40, 0XCC,
0XE1, 0XAB, 0XC1, 0XED, 0X80, 0XFD, 0X60, 0XFD, 0X60, 0XE4, 0X29, 0XB4, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0X15, 0XD6, 0XE0, 0XBB, 0X60, 0XFE, 0XC8, 0XFE, 0XC8, 0XFE, 0X02, 0XFF,
0X60, 0XDD, 0X40, 0XA3, 0XA1, 0XDD, 0X40, 0XFF, 0X20, 0XFF, 0X20, 0XFF, 0X20, 0XFF, 0X20, 0XFF,
0X20, 0XFF, 0X20, 0XFF, 0X20, 0XFF, 0X00, 0XFF, 0XE0, 0XFE, 0XC0, 0XFE, 0XC0, 0XFE, 0XA0, 0XFE,
0X80, 0XFE, 0X60, 0XFE, 0X40, 0XFE, 0X20, 0XFE, 0X20, 0XFE, 0X20, 0XFE, 0X20, 0XFE, 0X40, 0XED,
0XC0, 0X9A, 0X40, 0XA3, 0X80, 0XF5, 0X60, 0XFD, 0X60, 0XBB, 0XEE, 0XBC, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XDF, 0XFF, 0X63, 0XAB, 0X42, 0XE5, 0XB4, 0XFF, 0X97, 0XFF, 0XAA, 0XF6,
0X80, 0XAB, 0XA0, 0X92, 0XA1, 0XDD, 0X41, 0XFF, 0X40, 0XFF, 0X60, 0XFF, 0X60, 0XFF, 0X60, 0XFF,
0X60, 0XFF, 0X40, 0XFF, 0X40, 0XFF, 0X40, 0XFF, 0X20, 0XFF, 0X20, 0XFF, 0X00, 0XFF, 0XE0, 0XFE,
0XC0, 0XFE, 0X80, 0XFE, 0X61, 0XFE, 0X00, 0XFE, 0XA0, 0XED, 0X20, 0XE5, 0X21, 0XCC, 0X80, 0XB3,
0X00, 0XBC, 0XE0, 0XC3, 0X40, 0XED, 0XC0, 0XEC, 0X60, 0X92, 0X97, 0XE6, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0X0F, 0XC5, 0X00, 0XA3, 0XAA, 0XF6, 0X93, 0XFF, 0X2D, 0XEE,
0X63, 0XDD, 0X80, 0XD5, 0X42, 0XB4, 0X82, 0XCC, 0X00, 0XCD, 0X40, 0XD5, 0XA0, 0XDD, 0XE1, 0XE5,
0XC1, 0XE5, 0XC1, 0XE5, 0XC1, 0XE5, 0XC1, 0XE5, 0X80, 0XDD, 0X60, 0XDD, 0X20, 0XD5, 0XC0, 0XCC,
0XA0, 0XCC, 0X61, 0XC4, 0X21, 0XC4, 0X01, 0XBC, 0X01, 0XBC, 0XE0, 0XBB, 0XC0, 0XBB, 0X60, 0XD4,
0X80, 0XFD, 0X40, 0XFD, 0X80, 0XFD, 0X80, 0XBB, 0X2B, 0XAC, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0X9D, 0XF7, 0X87, 0XA3, 0X60, 0XD4, 0X0A, 0XFF, 0XCF, 0XFE,
0XC9, 0XFE, 0XC0, 0XFE, 0XC0, 0XF6, 0X40, 0XE6, 0X41, 0XCD, 0X42, 0XB4, 0XC1, 0XAB, 0X60, 0XA3,
0X60, 0XA3, 0X80, 0XA3, 0X80, 0XA3, 0X80, 0XA3, 0XA0, 0XAB, 0XC1, 0XAB, 0XE1, 0XB3, 0X22, 0XB4,
0X82, 0XC4, 0XC0, 0XCC, 0X00, 0XD5, 0X60, 0XE5, 0X81, 0XED, 0X80, 0XF5, 0X80, 0XFD, 0X80, 0XFD,
0X40, 0XFD, 0X80, 0XFD, 0X80, 0XE4, 0X85, 0XAB, 0X5C, 0XEF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFA, 0XE6, 0X23, 0XA3, 0XE0, 0XE4, 0XE8, 0XFE,
0X6A, 0XFE, 0X05, 0XFE, 0X40, 0XFE, 0XA0, 0XFE, 0XC0, 0XFE, 0XE1, 0XFE, 0XA0, 0XF6, 0XA0, 0XF6,
0XA0, 0XF6, 0XA0, 0XF6, 0X80, 0XF6, 0X80, 0XF6, 0X80, 0XF6, 0X60, 0XF6, 0X61, 0XFE, 0X81, 0XFE,
0X61, 0XFE, 0X20, 0XFE, 0X00, 0XFE, 0XC0, 0XFD, 0X80, 0XFD, 0X60, 0XFD, 0X20, 0XFD, 0X20, 0XFD,
0X60, 0XFD, 0X20, 0XF5, 0XA0, 0XA2, 0XB4, 0XCD, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0X52, 0XC5, 0XE0, 0XA2, 0XA1, 0XF5,
0X86, 0XFE, 0X06, 0XFE, 0XE2, 0XFD, 0XE0, 0XFD, 0X00, 0XFE, 0X20, 0XFE, 0X20, 0XFE, 0X20, 0XFE,
0X40, 0XFE, 0X20, 0XFE, 0X20, 0XFE, 0X20, 0XFE, 0X00, 0XFE, 0XE0, 0XFD, 0XE0, 0XFD, 0XC0, 0XFD,
0XA0, 0XFD, 0X80, 0XFD, 0X60, 0XFD, 0X40, 0XFD, 0X20, 0XFD, 0X20, 0XFD, 0X20, 0XFD, 0X40, 0XFD,
0X60, 0XFD, 0X60, 0XBB, 0X6C, 0XB4, 0XDE, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0X92, 0XCD, 0XC0, 0XA2,
0X20, 0XED, 0X22, 0XFE, 0XC1, 0XFD, 0XA0, 0XFD, 0XC0, 0XFD, 0XE0, 0XFD, 0XE0, 0XFD, 0XE0, 0XFD,
0XE0, 0XFD, 0XE0, 0XFD, 0XC0, 0XFD, 0XC0, 0XFD, 0XC0, 0XFD, 0XC0, 0XFD, 0XA0, 0XFD, 0X80, 0XFD,
0X80, 0XFD, 0X60, 0XFD, 0X40, 0XFD, 0X20, 0XFD, 0X20, 0XFD, 0X20, 0XFD, 0X60, 0XFD, 0X40, 0XFD,
0X20, 0XB3, 0XEA, 0XA3, 0X9D, 0XF7, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0X8E, 0XBC,
0XE1, 0XA2, 0X00, 0XE5, 0XE0, 0XFD, 0XC0, 0XFD, 0XA0, 0XFD, 0XA0, 0XFD, 0XA0, 0XFD, 0XA0, 0XFD,
0XC0, 0XFD, 0XA0, 0XFD, 0XA0, 0XFD, 0XA0, 0XFD, 0XA0, 0XFD, 0X80, 0XFD, 0X80, 0XFD, 0X60, 0XFD,
0X40, 0XFD, 0X20, 0XFD, 0X20, 0XFD, 0X20, 0XFD, 0X20, 0XFD, 0X80, 0XFD, 0X00, 0XF5, 0X40, 0XBB,
0X2B, 0XAC, 0X9D, 0XF7, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0X35, 0XD6, 0XE2, 0X9A, 0XA0, 0XC3, 0XA0, 0XFD, 0XE0, 0XFD, 0X80, 0XFD, 0X60, 0XFD, 0X80, 0XFD,
0X80, 0XFD, 0X60, 0XFD, 0X60, 0XFD, 0X60, 0XFD, 0X60, 0XFD, 0X60, 0XFD, 0X40, 0XFD, 0X40, 0XFD,
0X20, 0XFD, 0X20, 0XFD, 0X40, 0XFD, 0X60, 0XFD, 0X60, 0XFD, 0X00, 0XD4, 0XC1, 0X9A, 0X10, 0XC5,
0XDE, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0X98, 0XDE, 0X2B, 0XAC, 0X40, 0XB3, 0X00, 0XD4, 0X40, 0XFD, 0X80, 0XFD, 0X80, 0XFD,
0X60, 0XFD, 0X40, 0XFD, 0X40, 0XFD, 0X40, 0XFD, 0X40, 0XFD, 0X40, 0XFD, 0X40, 0XFD, 0X40, 0XFD,
0X40, 0XFD, 0X60, 0XFD, 0X40, 0XFD, 0X40, 0XDC, 0X80, 0XBB, 0XE8, 0XAB, 0X57, 0XDE, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XDF, 0XFF, 0X37, 0XD6, 0X86, 0XA3, 0XC0, 0X9A, 0XE0, 0XCB, 0X80, 0XEC,
0XE0, 0XF4, 0X20, 0XFD, 0X20, 0XFD, 0X20, 0XFD, 0X20, 0XFD, 0X20, 0XFD, 0X20, 0XFD, 0X00, 0XF5,
0XA0, 0XEC, 0X00, 0XD4, 0X40, 0XB3, 0X03, 0X9B, 0X92, 0XC5, 0XBD, 0XF7, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XBE, 0XF7, 0XF5, 0XCD, 0XAD, 0XBC, 0X69, 0XBC,
0X05, 0XBC, 0X03, 0XC4, 0X01, 0XC4, 0X01, 0XC4, 0X01, 0XC4, 0X01, 0XC4, 0XE2, 0XC3, 0X24, 0XC4,
0X68, 0XBC, 0XAC, 0XBC, 0XD3, 0XCD, 0X9E, 0XF7, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0X5B, 0XEF, 0X98, 0XDE, 0X56, 0XD6, 0X57, 0XD6, 0X57, 0XD6, 0X56, 0XD6, 0X77, 0XDE, 0X1B, 0XEF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF,
};
const unsigned char PROGMEM wifi_full[2048] = {
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x49, 0x21, 0x71, 0xC2, 0x71, 0xC2, 0x71, 0xC2, 0x71, 0xC2,
0x71, 0xC2, 0x71, 0xC2, 0x71, 0xC2, 0x71, 0xC2, 0x71, 0xC2, 0x71, 0xC2, 0x71, 0xC2, 0x71, 0xC2,
0x71, 0xC2, 0x71, 0xC2, 0x71, 0xC2, 0x71, 0xC2, 0x71, 0xC2, 0x71, 0xC2, 0x71, 0xC2, 0x71, 0xC2,
0x71, 0xC2, 0x71, 0xC2, 0x71, 0xC2, 0x71, 0xC2, 0x41, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x28, 0xA0, 0xCB, 0x23, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4,
0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4,
0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4,
0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xC3, 0x03, 0x18, 0x60, 0x00, 0x00,
0x08, 0x20, 0xD3, 0x23, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4,
0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4,
0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4,
0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xC3, 0x03, 0x00, 0x00,
0x59, 0x61, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4,
0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4,
0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4,
0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0x41, 0x01,
0x8A, 0x22, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4,
0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4,
0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4,
0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0x71, 0xC2,
0x92, 0x42, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4,
0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4,
0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4,
0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0x71, 0xC2,
0x92, 0x42, 0xF4, 0x89, 0xFE, 0x34, 0xFE, 0xB7, 0xFF, 0x19, 0xFF, 0x3A, 0xFF, 0x3A, 0xFE, 0xD8,
0xFE, 0x76, 0xF5, 0xD1, 0xF5, 0x0C, 0xEB, 0xE6, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4,
0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4,
0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0x71, 0xC2,
0x92, 0x42, 0xF4, 0xEC, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x19, 0xF5, 0x90, 0xEC, 0x06, 0xEB, 0xA4,
0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4,
0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0x71, 0xC2,
0x92, 0x42, 0xF4, 0x06, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFE, 0x54,
0xF4, 0x47, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4,
0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0x71, 0xC2,
0x92, 0x42, 0xEB, 0xA4, 0xFF, 0x9D, 0xFF, 0xFF, 0xFF, 0xBD, 0xFF, 0x7C, 0xFF, 0x7C, 0xFF, 0x9D,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xF6, 0x13, 0xEB, 0xE5, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4,
0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0x71, 0xC2,
0x92, 0x42, 0xEB, 0xA4, 0xF4, 0x47, 0xEB, 0xE5, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4,
0xEB, 0xC4, 0xF4, 0x48, 0xF5, 0x2E, 0xFE, 0x55, 0xFF, 0xBD, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x7C, 0xF4, 0xAA, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4,
0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0x71, 0xC2,
0x92, 0x42, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4,
0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xC4, 0xF5, 0x0C, 0xFE, 0xF9, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF5, 0xB1, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4,
0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0x71, 0xC2,
0x92, 0x42, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xF4, 0x27, 0xF4, 0xCB, 0xF5, 0x0C, 0xF5, 0x0C,
0xF4, 0xAB, 0xF4, 0x27, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xF4, 0xEC,
0xFF, 0x7C, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFE, 0x34, 0xEB, 0xC4, 0xEB, 0xA4,
0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0x71, 0xC2,
0x92, 0x42, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xFE, 0xF8, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x9D, 0xFE, 0x76, 0xF4, 0xEC, 0xEB, 0xC4, 0xEB, 0xA4, 0xEB, 0xA4,
0xEB, 0xC5, 0xFE, 0x34, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFE, 0x55, 0xEB, 0xA4,
0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0x71, 0xC2,
0x92, 0x42, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xF6, 0x13, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x7C, 0xF5, 0x6F, 0xEB, 0xC4,
0xEB, 0xA4, 0xEB, 0xA4, 0xF5, 0x4E, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF5, 0xF2,
0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0x71, 0xC2,
0x92, 0x42, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xF4, 0x69, 0xF5, 0x0C, 0xF4, 0xAA, 0xF4, 0x89,
0xF4, 0xCB, 0xF5, 0x6F, 0xFE, 0x55, 0xFF, 0x9D, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x1A,
0xF4, 0x48, 0xEB, 0xA4, 0xEB, 0xA4, 0xF5, 0x0C, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xF5, 0x0D, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0x71, 0xC2,
0x92, 0x42, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4,
0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xC4, 0xF4, 0xEC, 0xFF, 0x19, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xDE, 0xF5, 0x0D, 0xEB, 0xA4, 0xEB, 0xA4, 0xF5, 0x4E, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xBE, 0xF4, 0x27, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0x71, 0xC2,
0x92, 0x42, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4,
0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xF5, 0x4E, 0xFF, 0xDE,
0xFF, 0xFF, 0xFF, 0xFF, 0xF5, 0x4E, 0xEB, 0xA4, 0xEB, 0xA4, 0xFE, 0x54, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFE, 0xB7, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0x71, 0xC2,
0x92, 0x42, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xC4, 0xFF, 0x3A, 0xFF, 0x9D,
0xFF, 0x9C, 0xFF, 0x19, 0xF6, 0x13, 0xF4, 0xAA, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xF4, 0x48,
0xFF, 0x7C, 0xFF, 0xFF, 0xFF, 0xFF, 0xF4, 0xEC, 0xEB, 0xA4, 0xEB, 0xC5, 0xFF, 0x7C, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xF4, 0xEC, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0x71, 0xC2,
0x92, 0x42, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xFE, 0xD8, 0xFF, 0x19,
0xFF, 0x19, 0xFF, 0x9C, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x1A, 0xF4, 0xAA, 0xEB, 0xA4, 0xEB, 0xA4,
0xF4, 0x47, 0xFF, 0x9D, 0xFF, 0xFF, 0xFF, 0xBE, 0xF4, 0x47, 0xEB, 0xA4, 0xF4, 0xEC, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x19, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0x71, 0xC2,
0x92, 0x42, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4,
0xEB, 0xA4, 0xEB, 0xA4, 0xF4, 0x27, 0xF5, 0xD1, 0xFF, 0xBD, 0xFF, 0xFF, 0xF5, 0xD2, 0xEB, 0xA4,
0xEB, 0xA4, 0xF4, 0xAA, 0xFF, 0xFF, 0xFF, 0xFF, 0xFE, 0xD8, 0xEB, 0xA4, 0xEB, 0xA4, 0xFE, 0xF9,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF4, 0xCB, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0x71, 0xC2,
0x92, 0x42, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4,
0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEC, 0x06, 0xFE, 0xB7, 0xFF, 0xFF, 0xFE, 0x34,
0xEB, 0xA4, 0xEB, 0xA4, 0xF6, 0x13, 0xFF, 0xFF, 0xFF, 0xFF, 0xF4, 0xEC, 0xEB, 0xA4, 0xF5, 0x0C,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFE, 0x55, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0x71, 0xC2,
0x92, 0x42, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4,
0xF4, 0x27, 0xF5, 0x4E, 0xF5, 0x2D, 0xEB, 0xE5, 0xEB, 0xA4, 0xEB, 0xC4, 0xFE, 0x96, 0xFF, 0xFF,
0xF5, 0x6F, 0xEB, 0xA4, 0xEB, 0xE5, 0xFF, 0xBE, 0xFF, 0xFF, 0xFE, 0xF9, 0xEB, 0xA4, 0xEB, 0xC4,
0xFF, 0x9D, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xDE, 0xEB, 0xC5, 0xEB, 0xA4, 0xEB, 0xA4, 0x71, 0xC2,
0x92, 0x42, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xEB, 0xA4, 0xF4, 0xEC,
0xFF, 0xDF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x9D, 0xEC, 0x48, 0xEB, 0x84, 0xEB, 0xC5, 0xFF, 0x5B,
0xFF, 0xDE, 0xEC, 0x07, 0xE3, 0x84, 0xF5, 0xF3, 0xFF, 0xFF, 0xFF, 0xFF, 0xEC, 0x28, 0xE3, 0x84,
0xF6, 0x14, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xEC, 0xAB, 0xE3, 0x64, 0xE3, 0x64, 0x79, 0xE2,
0xAA, 0x64, 0xB2, 0x84, 0xB2, 0x84, 0xB2, 0x84, 0xB2, 0x84, 0xB2, 0x84, 0xB2, 0xC5, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xEE, 0x98, 0xB2, 0x84, 0xB2, 0x84, 0xC4, 0x0C,
0xFF, 0xFF, 0xDD, 0x93, 0xB2, 0x84, 0xBB, 0x69, 0xFF, 0xFF, 0xFF, 0xFF, 0xD5, 0x11, 0xB2, 0x84,
0xCC, 0x4D, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xDD, 0x32, 0xB2, 0x84, 0xB2, 0x84, 0x92, 0x23,
0xAA, 0x64, 0xB2, 0x84, 0xB2, 0x84, 0xB2, 0x84, 0xB2, 0x84, 0xB2, 0x84, 0xC3, 0x8A, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xDF, 0xB2, 0x84, 0xB2, 0x84, 0xB2, 0x84,
0xF7, 0x3B, 0xFF, 0x9D, 0xB2, 0x85, 0xB2, 0x84, 0xF7, 0x5C, 0xEE, 0xFA, 0xD4, 0xD0, 0xB2, 0x84,
0xB2, 0xE6, 0xDD, 0x93, 0xCC, 0x6E, 0xBB, 0x68, 0xB2, 0x85, 0xB2, 0x84, 0xB2, 0x84, 0x92, 0x23,
0xAA, 0x64, 0xB2, 0x84, 0xB2, 0x84, 0xB2, 0x84, 0xB2, 0x84, 0xB2, 0x84, 0xBB, 0x07, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF7, 0x5C, 0xB2, 0x84, 0xB2, 0x84, 0xB2, 0x84,
0xDD, 0x52, 0xEE, 0xD9, 0xBB, 0x07, 0xB2, 0x84, 0xB2, 0x85, 0xB2, 0x84, 0xB2, 0x84, 0xB2, 0x84,
0xB2, 0x84, 0xB2, 0x84, 0xB2, 0x84, 0xB2, 0x84, 0xB2, 0x84, 0xB2, 0x84, 0xB2, 0x84, 0x92, 0x23,
0xA2, 0x64, 0xB2, 0x84, 0xB2, 0x84, 0xB2, 0x84, 0xB2, 0x84, 0xB2, 0x84, 0xB2, 0x84, 0xE5, 0xD5,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xCC, 0xAF, 0xB2, 0x84, 0xB2, 0x84, 0xB2, 0x84,
0xB2, 0x84, 0xB2, 0x84, 0xB2, 0x84, 0xB2, 0x84, 0xB2, 0x84, 0xB2, 0x84, 0xB2, 0x84, 0xB2, 0x84,
0xB2, 0x84, 0xB2, 0x84, 0xB2, 0x84, 0xB2, 0x84, 0xB2, 0x84, 0xB2, 0x84, 0xB2, 0x84, 0x92, 0x23,
0x9A, 0x43, 0xB2, 0x84, 0xB2, 0x84, 0xB2, 0x84, 0xB2, 0x84, 0xB2, 0x84, 0xB2, 0x84, 0xB2, 0xA5,
0xD4, 0xF0, 0xEE, 0x99, 0xEE, 0x78, 0xCC, 0x4D, 0xB2, 0x84, 0xB2, 0x84, 0xB2, 0x84, 0xB2, 0x84,
0xB2, 0x84, 0xB2, 0x84, 0xB2, 0x84, 0xB2, 0x84, 0xB2, 0x84, 0xB2, 0x84, 0xB2, 0x84, 0xB2, 0x84,
0xB2, 0x84, 0xB2, 0x84, 0xB2, 0x84, 0xB2, 0x84, 0xB2, 0x84, 0xB2, 0x84, 0xB2, 0x84, 0x79, 0xC3,
0x81, 0xE3, 0xB2, 0x84, 0xB2, 0x84, 0xB2, 0x84, 0xB2, 0x84, 0xB2, 0x84, 0xB2, 0x84, 0xB2, 0x84,
0xB2, 0x84, 0xB2, 0x84, 0xB2, 0x84, 0xB2, 0x84, 0xB2, 0x84, 0xB2, 0x84, 0xB2, 0x84, 0xB2, 0x84,
0xB2, 0x84, 0xB2, 0x84, 0xB2, 0x84, 0xB2, 0x84, 0xB2, 0x84, 0xB2, 0x84, 0xB2, 0x84, 0xB2, 0x84,
0xB2, 0x84, 0xB2, 0x84, 0xB2, 0x84, 0xB2, 0x84, 0xB2, 0x84, 0xB2, 0x84, 0xB2, 0x84, 0x59, 0x42,
0x79, 0xC3, 0xB2, 0x84, 0xB2, 0x84, 0xB2, 0x84, 0xB2, 0x84, 0xB2, 0x84, 0xB2, 0x84, 0xB2, 0x84,
0xB2, 0x84, 0xB2, 0x84, 0xB2, 0x84, 0xB2, 0x84, 0xB2, 0x84, 0xB2, 0x84, 0xB2, 0x84, 0xB2, 0x84,
0xB2, 0x84, 0xB2, 0x84, 0xB2, 0x84, 0xB2, 0x84, 0xB2, 0x84, 0xB2, 0x84, 0xB2, 0x84, 0xB2, 0x84,
0xB2, 0x84, 0xB2, 0x84, 0xB2, 0x84, 0xB2, 0x84, 0xB2, 0x84, 0xB2, 0x84, 0xB2, 0x84, 0x59, 0x42,
0x51, 0x42, 0x79, 0xC3, 0x79, 0xC3, 0x9A, 0x23, 0xA2, 0x63, 0xA2, 0x63, 0xA2, 0x63, 0xA2, 0x63,
0xA2, 0x63, 0xA2, 0x63, 0xA2, 0x63, 0xA2, 0x63, 0xA2, 0x63, 0xA2, 0x63, 0xA2, 0x63, 0xA2, 0x63,
0xA2, 0x63, 0xA2, 0x63, 0xA2, 0x63, 0xA2, 0x63, 0xA2, 0x63, 0xA2, 0x63, 0xA2, 0x63, 0xA2, 0x63,
0xA2, 0x63, 0xA2, 0x63, 0xA2, 0x63, 0xA2, 0x63, 0x92, 0x23, 0x79, 0xC3, 0x79, 0xC3, 0x38, 0xE1,
};
libraries/MCUFRIEND_kbv/extras/unused/ili9341_init.h
+138
View File
@@ -0,0 +1,138 @@
/* 1.2 LG 2.6” Initial Code*/
void ILI9341_LG2.6_Initial(void)
{
/* VCI=2.8V*/
/************** Reset LCD Driver ****************//*/
LCD_nRESET = 1;
delayms(1); /* Delay 1ms*/
LCD_nRESET = 0;
delayms(10); /* Delay 10ms // This delay time is necessary*/
LCD_nRESET = 1;
delayms(120); /* Delay 120 ms*/
/************** Start Initial Sequence **********//*/
(0xCB),0x39,0x2C,0x00,0x34,0x02,
(0xCF),0x00,0xC1,0x30,
(0xE8),0x85,0x00,0x78,
(0xEA),0x00,0x00,
(0xED),0x64,0x03,0x12,0x81)
(0xF7),0x20,
(0xC0), /*Power control*/ 0x23, /*VRH[5:0]*/
(0xC1), /*Power control*/ 0x10, /*SAP[2:0];BT[3:0]*/
(0xC5), /*VCM control*/ 0x2B,0x2B,
/* (0xC7), /*VCM control2*/ */
/*LCD_ILI9341_INDEX(0xC0,*/
(0x36), /* Memory Access Control*/ 0x48,
(0xB1),0x00,0x1B,
(0xB6), /* Display Function Control*/ 0x0A,0x02,
(0xF2), /* 3Gamma Function Disable*/ 0x00,
(0x26), /*Gamma curve selected*/ 0x01,
(0xE0), /*Set Gamma*/ 0x0F,0x31,0x2B,0x0C,0x0E,0x08,0x4E,0xF1,0x37,0x07,0x10,0x03,0x0E,0x09,0x00,
(0xE1), /*Set Gamma*/ 0x00,0x0E,0x14,0x03,0x11,0x07,0x31,0xC1,0x48,0x08,0x0F,0x0C,0x31,0x36,0x0F,
(0x11), /*Exit Sleep*/
TFTLCD_DELAY8, 120,
(0x29), /*Display on*/
}
/* 2.2 BOE 2.0” Initial Code*/
void ILI9341_BOE2.0_Initial(void)
{
/* VCI=2.8V*/
/************** Reset LCD Driver ****************//*/
LCD_nRESET = 1;
delayms(1); /* Delay 1ms*/
LCD_nRESET = 0;
delayms(10); /* Delay 10ms // This delay time is necessary*/
LCD_nRESET = 1;
delayms(120); /* Delay 120 ms*/
/************** Start Initial Sequence **********//*/
(0xCF),0x00,0x99,0x30,
(0xED),0x64,0x03,0x12,0x81,
(0xE8),0x85,0x10,0x78,
(0xCB),0x39,0x2C,0x00,0x34,0x02,
(0xF7),0x20,
(0xEA),0x00,0x00,
(0xC0), /*Power control*/ 0x26, /*VRH[5:0]*/
(0xC1), /*Power control*/ 0x12, /*SAP[2:0];BT[3:0]*/
(0xC5), /*VCM control*/ 0x2B,0x2C,
(0xC7), /*VCM control2*/ 0xC4,
(0x36), /* Memory Access Control*/ 0x08,
(0xB1),0x00,0x1B,
(0xB6), /* Display Function Control*/ 0x0A,0xA2,
(0xF2), /* 3Gamma Function Disable*/ 0x00,
(0x26), /*Gamma curve selected*/ 0x01,
(0xE0), /*Set Gamma*/ 0x0F,0x24,0x21,0x0A,0x0E,0x09,0x51,0xA9,0x44,0x07,0x10,0x03,0x2C,0x0B,0x00,
(0xE1), /*Set Gamma*/ 0x00,0x1B,0x1E,0x05,0x11,0x06,0x2E,0x56,0x3B,0x08,0x0F,0x0C,0x13,0x14,0x0F,
(0x11), /*Exit Sleep*/
TFTLCD_DELAY8, 120,
(0x29), /*Display on*/
}
/* 2.3 BOE 2.4” Initial Code*/
void ILI9341_BOE2.4_Initial(void)
{
/* VCI=2.8V*/
/************** Reset LCD Driver ****************//*/
LCD_nRESET = 1;
delayms(1); /* Delay 1ms*/
LCD_nRESET = 0;
delayms(10); /* Delay 10ms // This delay time is necessary*/
LCD_nRESET = 1;
delayms(120); /* Delay 120 ms*/
/************** Start Initial Sequence **********//*/
(0xCF),0x00,0x81,0x30,
(0xED),0x64,0x03,0x12,0x81,
(0xE8),0x85,0x10,0x78,
(0xCB),0x39,0x2C,0x00,0x34,0x02,
(0xF7),0x20,
(0xEA),0x00,0x00,
(0xB1),0x00,0x1B,
(0xB6), /* Display Function Control*/ 0x0A,0xA2,
(0xC0), /*Power control*/ 0x21, /*VRH[5:0]*/
(0xC1), /*Power control*/ 0x11, /*SAP[2:0];BT[3:0]*/
(0xC5), /*VCM control*/ 0x3F,0x3C,
(0xC7), /*VCM control2*/ 0xb5,
(0x36), /* Memory Access Control*/ 0x48,
(0xF2), /* 3Gamma Function Disable*/ 0x00,
(0x26), /*Gamma curve selected*/ 0x01,
(0xE0), /*Set Gamma*/ 0x0F,0x26,0x24,0x0B,0x0E,0x09,0x54,0xA8,0x46,0x0C,0x17,0x09,0x0F,0x07,0x00,
(0xE1), /*Set Gamma*/ 0x00,0x19,0x1B,0x04,0x10,0x07,0x2A,0x47,0x39,0x03,0x06,0x06,0x30,0x38,0x0F,
(0x11), /*Exit Sleep*/
TFTLCD_DELAY8, 120,
(0x29), /*Display on*/
}
/* 3.2 Tianma 2.4” Initial Code*/
void ILI9341_Tianma2.4_Initial(void)
{
/* VCI=2.8V*/
/************** Reset LCD Driver ****************//*/
LCD_nRESET = 1;
delayms(1); /* Delay 1ms*/
LCD_nRESET = 0;
delayms(10); /* Delay 10ms // This delay time is necessary*/
LCD_nRESET = 1;
delayms(120); /* Delay 120 ms*/
/************** Start Initial Sequence **********//*/
(0xCF),0x00,0x81,0x30,
(0xED),0x64,0x03,0x12,0x81,
(0xE8),0x85,0x10,0x7A,
(0xCB),0x39,0x2C,0x00,0x34,0x02,
(0xF7),0x20,
(0xEA),0x00,0x00,
(0xC0), /*Power control*/ 0x21, /*VRH[5:0]*/
(0xC1), /*Power control*/ 0x11, /*SAP[2:0];BT[3:0]*/
(0xC5), /*VCM control*/ 0x3F,0x3C,
(0xC7), /*VCM control2*/ 0xa7,
(0x36), /* Memory Access Control*/ 0x48,
(0xB1),0x00,0x1B,
(0xB6), /* Display Function Control*/ 0x0A,0xA2,
(0xF2), /* 3Gamma Function Disable*/ 0x00,
(0x26), /*Gamma curve selected*/ 0x01,
(0xE0), /*Set Gamma*/ 0x0F,0x23,0x1F,0x0B,0x0E,0x08,0x4B,0xA8,0x3B,0x0A,0x14,0x06,0x10,0x09,0x00,
(0xE1), /*Set Gamma*/ 0x00,0x1C,0x20,0x04,0x10,0x08,0x34,0x47,0x44,0x05,0x0B,0x09,0x2F,0x36,0x0F,
(0x11), /*Exit Sleep*/
TFTLCD_DELAY8, 120,
(0x29), /*Display on*/
}
libraries/MCUFRIEND_kbv/extras/unused/ili9481_init.h
+114
View File
@@ -0,0 +1,114 @@
/* 1.2 CPT 2.9 Inch Initial Code*/
Void ILI9481_CPT_Initial_Code(void)
{
/* VCI=2.8V*/
/************** Reset LCD Driver ****************//*/
LCD_nRESET = 1;
delayms(1); /* Delay 1ms*/
LCD_nRESET = 0;
delayms(10); /* Delay 10ms // This delay time is necessary*/
LCD_nRESET = 1;
delayms(100); /* Delay 100 ms*/
/************** Start Initial Sequence **********//*/
(0x11),
TFTLCD_DELAY8, 20,
(0xD0),0x07,0x42,0x1C,
(0xD1),0x,0x02,0x0F,
(0xD2),0x01,0x11,
(0xC0),0x10,0x35,0x,0x02,0x11,
(0xC5),
LCD_ILI9481_INDEX(0x03);
(0xC8),0x,0x30,0x36,0x45,0x04,0x16,0x37,0x75,0x77,0x54,0x0F,0x,
(0xE4),0xA0,
(0xF0),0x01,
(0xF3),0x02,0x1A)
;
(0x36),0x0A,
(0x2A),0x,0x,0x01,0x3F,
(0x2B),0x,0x,0x01,0xAD,
TFTLCD_DELAY8, 120,
(0x29),
}
/* 2.2 PVI 3.5 Inch Initial Code*/
Void ILI9481_CPT_Initial_Code(void)
{
/* VCI=2.8V*/
/************** Reset LCD Driver ****************//*/
LCD_nRESET = 1;
delayms(1); /* Delay 1ms*/
LCD_nRESET = 0;
delayms(10); /* Delay 10ms // This delay time is necessary*/
LCD_nRESET = 1;
delayms(100); /* Delay 100 ms*/
/************** Start Initial Sequence **********//*/
(0x11),
TFTLCD_DELAY8, 20,
(0xD0),0x07,0x41,0x1D,
(0xD1),0x,0x2B,0x1F,
(0xD2),0x01,0x11,
(0xC0),0x,0x3B,0x,0x02,0x11,
(0xC5),0x03,
(0xC8),0x,0x14,0x33,0x10,0x,0x16,0x44,0x36,0x77,0x,0x0f,0x,
(0xE4),0xA0,
(0xF0),0x01,
(0xF3),0x40,0x0A,
(0x36),0x0A,
TFTLCD_DELAY8, 120,
(0x29),
/* 3.2. AUO 3.17 Inch Initial Code*/
Void ILI9481_AUO_Initial_Code(void)
{
/* VCI=2.8V*/
/************** Reset LCD Driver ****************//*/
LCD_nRESET = 1;
delayms(1); /* Delay 1ms*/
LCD_nRESET = 0;
delayms(10); /* Delay 10ms // This delay time is necessary*/
LCD_nRESET = 1;
delayms(100); /* Delay 100 ms*/
/************** Start Initial Sequence **********//*/
(0x11),
TFTLCD_DELAY8, 20,
(0xD0),0x07,0x40,0x1D,
(0xD1),0x,0x18,0x13,
(0xD2),0x01,0x11,
(0xC0),0x10,0x3B,0x,0x02,0x11,
(0xC5),0x03,
(0xC8),0x,0x44,0x06,0x44,0x0A,0x08,0x17,0x33,0x77,0x44,0x08,0x0c,
(0xE4),0xA0,
(0xF0),0x01,
(0x36),0x0A,
TFTLCD_DELAY8, 120,
(0x29),
/* 4.2. CMO 3.5 Inch Initial Code*/
(0x01),
DelayX1ms(120);
(0x11),
DelayX1ms(120);
/*Power Setting*/
(0xD0),0x07,0x41,0x1D,
DelayX1ms(20);
/*Vcom Setting*/
(0xD1),0x00,0x1C,/*18*/ 0x1F,
/*Power Setting for normal mode*/
(0xD2),0x01,0x11,
(0xC0), /*Panel Driving Setting*/ 0x00,0x3B,0x00,0x02,0x11,
(0xC6),0x83,
(0xC8),0x00,0x26,0x21,0x00,0x00,0x1F,0x65,0x23,0x77,0x00,0x0F,0x00,
(0xF0),0x01,
/* (0xE4),*/
/*LCD_ILI9481_INDEX(0xA0,*/
(0x36),0x48,/*0x08 _BGR,0x _RGB*/
/*Set display on*/
(0x29),
(0xB4),0x11,
(0x2C),
libraries/MCUFRIEND_kbv/extras/unused/ili9486_init.h
+158
View File
@@ -0,0 +1,158 @@
/* 1.2CPT 3.5 Inch Initial Code*/
Void ILI9486_CPT_Initial_Code(void)
{/* VCI=2.8V*/
/************** Reset LCD Driver ****************//*/
LCD_nRESET = 1;
TFTLCD_DELAY8, 1, /* Delay 1ms*/
LCD_nRESET = 0;
TFTLCD_DELAY8, 10, /* Delay 10ms // This delay time is necessary*/
LCD_nRESET = 1;
TFTLCD_DELAY8, 120, /* Delay 120 ms*/
/************** Start Initial Sequence **********/**/ */
(0xF2),0x18,0xA3,0x12,0x02,0xB2,0x12,0xFF,0x10,0x00,
(0xF8),0x21,0x04,
(0xF9),0x00,0x08,
(0x36),0x08,
(0xB4),0x00,
(0xC1),0x41,
(0xC5),0x00,0x53,
(0xE0),0x0F,0x1B,0x18,0x0B,0x0E,0x09,0x47,0x94,0x35,0x0A,0x13,0x05,0x08,0x03,0x00,
(0xE1),0x0F,0x3A,0x37,0x0B,0x0C,0x05,0x4A,0x24,0x39,0x07,0x10,0x04,0x27,0x25,0x00,
(0x11),
TFTLCD_DELAY8, 120,
(0x29),
}
Void ILI9486_EnterSleep_Code(void)
{
(0x28))
TFTLCD_DELAY8, 10,
(0x10), /* Set_address_mode*/
TFTLCD_DELAY8, 120,
}
Void ILI9486_ExitSleep_Code(void)
{
(0x11), /* Set_address_mode*/
TFTLCD_DELAY8, 120,
(0x29))
}
/* 2.2 HSD 3.5 Inch Initial Code*/
Void ILI9486_HSD_Initial_Code(void)
{/* VCI=2.8V*/
/************** Reset LCD Driver ****************//*/
LCD_nRESET = 1;
TFTLCD_DELAY8, 1, /* Delay 1ms*/
LCD_nRESET = 0;
TFTLCD_DELAY8, 10, /* Delay 10ms // This delay time is necessary*/
LCD_nRESET = 1;
TFTLCD_DELAY8, 120, /* Delay 120 ms*/
/************** Start Initial Sequence **********/**/ */
(0xF2),0x18,0xA3,0x12,0x02,0xB2,0x12,0xFF,0x10,0x00,
(0xF8),0x21,0x04,
(0xF9),0x00,0x08,
(0x36),0x08,
(0xB4),0x00,
(0xB6),0x02,0x22,
(0xC1),0x41,
(0xC5),0x00,0x18,
(0xE0),0x0F,0x1F,0x1C,0x0C,0x0F,0x08,0x48,0x98,0x37,0x0A,0x13,0x04,0x11,0x0D,0x00,
(0xE1),0x0F,0x32,0x2E,0x0B,0x0D,0x05,0x47,0x75,0x37,0x06,0x10,0x03,0x24,0x20,0x00,
(0x11),
TFTLCD_DELAY8, 120,
(0x29),
}
Void ILI9486_EnterSleep_Code(void)
{
(0x28))
TFTLCD_DELAY8, 10,
(0x10),
TFTLCD_DELAY8, 120,
}
Void ILI9486_ExitSleep_Code(void)
{
(0x11),
TFTLCD_DELAY8, 120,
(0x29))
}
/* 3.2 TM 3.2 Inch Initial Code*/
Void ILI9486_TM_Initial_Code(void)
{/* VCI=2.8V*/
/************** Reset LCD Driver ****************//*/
LCD_nRESET = 1;
TFTLCD_DELAY8, 1, /* Delay 1ms*/
LCD_nRESET = 0;
TFTLCD_DELAY8, 10, /* Delay 10ms // This delay time is necessary*/
LCD_nRESET = 1;
TFTLCD_DELAY8, 120, /* Delay 120 ms*/
/************** Start Initial Sequence **********/**/ */
(0xF2),0x18,0xA3,0x12,0x02,0xB2,0x12,0xFF,0x10,0x00,
(0xF8),0x21,0x04,
(0xF9),0x00,0x08,
(0x36),0x08,
(0xB4),0x00,
(0xB6),0x02,0x22,
(0xC1),0x41,
(0xC5),0x00,0x55,
(0xE0),0x0F,0x21,0x1C,0x0B,0x0E,0x08,0x49,0x98,0x38,0x09,0x11,0x03,0x14,0x10,0x00,
(0xE1),0x0F,0x2F,0x2B,0x0C,0x0E,0x06,0x47,0x76,0x37,0x07,0x11,0x04,0x23,0x1E,0x00,
(0x11),
TFTLCD_DELAY8, 120,
(0x29),
}
Void ILI9486_EnterSleep_Code(void)
{
(0x28))
TFTLCD_DELAY8, 10,
(0x10),
TFTLCD_DELAY8, 120,
}
Void ILI9486_ExitSleep_Code(void)
{
(0x11),
TFTLCD_DELAY8, 120,
(0x29))
}
/* 4.2 WTK 3.5 Inch Initial Code*/
Void ILI9486_WTK_Initial_Code(void)
{/* VCI=2.8V*/
/************** Reset LCD Driver ****************//*/
LCD_nRESET = 1;
TFTLCD_DELAY8, 1, /* Delay 1ms*/
LCD_nRESET = 0;
TFTLCD_DELAY8, 10, /* Delay 10ms // This delay time is necessary*/
LCD_nRESET = 1;
TFTLCD_DELAY8, 120, /* Delay 120 ms*/
/************** Start Initial Sequence **********/**/ */
(0xF2),0x18,0xA3,0x12,0x02,0xB2,0x12,0xFF,0x10,0x00,
(0xF8),0x21,0x04,
(0xF9),0x00,0x08,
(0x21),
(0x36),0x08,
(0xB4),0x00,
(0xB6),0x02,0x22,
(0xC1),0x41,
(0xC5),0x00,0x53,
(0xE0),0x0F,0x10,0x08,0x05,0x09,0x05,0x37,0x98,0x26,0x07,0x0F,0x02,0x09,0x07,0x00,
(0xE1),0x0F,0x38,0x36,0x0D,0x10,0x08,0x59,0x76,0x48,0x0A,0x16,0x0A,0x37,0x2F,0x00,
(0x11),
TFTLCD_DELAY8, 120,
(0x29),
}
Void ILI9486_EnterSleep_Code(void)
{
(0x28))
TFTLCD_DELAY8, 10,
(0x10),
TFTLCD_DELAY8, 120,
}
Void ILI9486_ExitSleep_Code(void)
{
(0x11),
TFTLCD_DELAY8, 120,
(0x29))
}
libraries/MCUFRIEND_kbv/extras/unused/mcufriend_special_2.h
+1915
View File
File diff suppressed because it is too large. Load diff
libraries/MCUFRIEND_kbv/extras/unused/mcufriend_special_3.h
+490
View File
@@ -0,0 +1,490 @@
//################################# SSD1289 SHIELD #######################
#define SSD1289_JUMPERS 2 //Uno Shield with VERY different pin-out to Mcufriend
//#define USE_SSD1289_SHIELD_UNO
//#define USE_SSD1289_SHIELD_MEGA
//#define USE_SSD1289_SHIELD_DUE
#elif defined(__AVR_ATmega328P__) && defined(USE_SSD1289_SHIELD_UNO) //on UNO
#warning using SSD1289 Shield for mega328
#define RD_PORT PORTC
#define RD_PIN 3
#define WR_PORT PORTC
#define WR_PIN 2
#define CD_PORT PORTC
#define CD_PIN 1
#define CS_PORT PORTC
#define CS_PIN 0
#define RESET_PORT PORTB
#define RESET_PIN 1 //actually SD_CS
// SSD1289 shield has LCD_D0 on RXD0. Fine for write-only
// For any Read operations, put jumper from D0 to D8, Switch #2 to OFF.
// If using Serial, jumper D1 to A5, Switch #1 to OFF
#if SSD1289_JUMPERS == 0
#warning no jumpers. Switch #1=ON, #2=ON
#define BMASK 0x00 //0x00 for output, 0x01 for Read + Serial
#define CMASK 0x00 //0x20 for Read + Serial
#define DMASK (~BMASK)
#define write8(x) { PORTD = x; WR_STROBE; }
#define read_8() ( PIND )
#elif SSD1289_JUMPERS == 1
#warning jumper D0 to D8. Switch #1=ON, #2=OFF
#define BMASK 0x01 //0x00 for output, 0x01 for Read + Serial
#define CMASK 0x00 //0x20 for Read + Serial
#define DMASK (~BMASK)
#define write8(x) { PORTD = (PORTD & ~DMASK) | (x & DMASK); PORTB = (PORTB & ~BMASK) | (x & BMASK); WR_STROBE; }
#define read_8() ( (PIND & DMASK)|(PINB & BMASK) )
#elif SSD1289_JUMPERS == 2
#warning jumper D0 to D8, D1 to A5. Switch #1=OFF, #2=OFF
#define BMASK (1<<0) //0x00 for output, 0x01 for Read + Serial
#define CMASK (1<<5) //0x20 for Read + Serial
#define DMASK (0xFC)
#define write8(x) { PORTC = (PORTC & ~CMASK) | ((x<<4) & CMASK);\
PORTD = (PORTD & ~DMASK) | (x & DMASK);\
PORTB = (PORTB & ~BMASK) | (x & BMASK); WR_STROBE; }
#define read_8() ( ((PINC & CMASK)>>4)|(PIND & DMASK)|(PINB & BMASK) )
#endif
#define setWriteDir() { DDRC |= CMASK; DDRD |= DMASK; DDRB |= BMASK; }
#define setReadDir() { DDRC &= ~CMASK; DDRD &= ~DMASK; DDRB &= ~BMASK; }
#define write16(x) { uint8_t h = (x)>>8, l = x; write8(h); write8(l); }
#define READ_8(dst) { RD_STROBE; dst = read_8(); RD_IDLE; }
#define READ_16(dst) { uint8_t hi; READ_8(hi); READ_8(dst); dst |= (hi << 8); }
#define PIN_LOW(p, b) (p) &= ~(1<<(b))
#define PIN_HIGH(p, b) (p) |= (1<<(b))
#define PIN_OUTPUT(p, b) *(&p-1) |= (1<<(b))
#elif defined(__AVR_ATmega2560__) && defined(USE_SSD1289_SHIELD_MEGA) //on MEGA2560
#warning using SSD1289 Shield for mega2560
#define RD_PORT PORTF
#define RD_PIN 3 //A3
#define WR_PORT PORTF
#define WR_PIN 2 //A2
#define CD_PORT PORTF
#define CD_PIN 1 //A1
#define CS_PORT PORTF
#define CS_PIN 0 //A0
#define RESET_PORT PORTH
#define RESET_PIN 6 //D9 DS_CS, D10=T_CS, D9=SD_CS, D8=n.c.
// only for SSD1289 data bus on D2..D9 UNTESTED
#if (SSD1289_JUMPERS == 0) //Switch #1=ON, #2=ON
#warning no jumpers Switch #1=ON, #2=ON
#define EMASK 0x3B
#define FMASK 0x00
#define HMASK 0x18
#define GMASK 0x20
#define write_8(x) { PORTH &= ~HMASK; PORTG &= ~GMASK; PORTE &= ~EMASK; \
PORTE |= (((x) & (1<<0)) << 0); \
PORTE |= (((x) & (1<<1)) << 0); \
PORTE |= (((x) & (3<<2)) << 2); \
PORTG |= (((x) & (1<<4)) << 1); \
PORTE |= (((x) & (1<<5)) >> 2); \
PORTH |= (((x) & (3<<6)) >> 3); \
}
#define read_8() ( ((PINE & (1<<0)) >> 0)\
| ((PINE & (1<<1)) >> 0)\
| ((PINE & (3<<4)) >> 2)\
| ((PING & (1<<5)) >> 1)\
| ((PINE & (1<<3)) << 2)\
| ((PINH & (3<<3)) << 3)\
)
#elif (SSD1289_JUMPERS == 1) //jumper D0 to D8. Switch #1=ON, #2=OFF
#warning jumper D0 to D8. Switch #1=ON, #2=OFF
#define EMASK 0x3A
#define FMASK 0x00
#define HMASK 0x38
#define GMASK 0x20
#define write_8(x) { PORTH &= ~HMASK; PORTG &= ~GMASK; PORTE &= ~EMASK; \
PORTH |= (((x) & (1<<0)) << 5); \
PORTE |= (((x) & (1<<1)) << 0); \
PORTE |= (((x) & (3<<2)) << 2); \
PORTG |= (((x) & (1<<4)) << 1); \
PORTE |= (((x) & (1<<5)) >> 2); \
PORTH |= (((x) & (3<<6)) >> 3); \
}
#define read_8() ( ((PINH & (1<<5)) >> 5)\
| ((PINE & (1<<1)) >> 0)\
| ((PINE & (3<<4)) >> 2)\
| ((PING & (1<<5)) >> 1)\
| ((PINE & (1<<3)) << 2)\
| ((PINH & (3<<3)) << 3)\
)
#elif (SSD1289_JUMPERS == 2) //jumper D0 to D8, D1 to A5. Switch #1=OFF, #2=OFF
#warning jumper D0 to D8, D1 to A5. Switch #1=OFF, #2=OFF
#define FMASK 0x20
#define EMASK 0x38
#define HMASK 0x38
#define GMASK 0x20
#define write_8(x) { PORTH &= ~HMASK; PORTG &= ~GMASK; PORTF &= ~FMASK; PORTE &= ~EMASK; \
PORTH |= (((x) & (1<<0)) << 5); \
PORTF |= (((x) & (1<<1)) << 4); \
PORTE |= (((x) & (3<<2)) << 2); \
PORTG |= (((x) & (1<<4)) << 1); \
PORTE |= (((x) & (1<<5)) >> 2); \
PORTH |= (((x) & (3<<6)) >> 3); \
}
#define read_8() ( ((PINH & (1<<5)) >> 5)\
| ((PINF & (1<<5)) >> 4)\
| ((PINE & (3<<4)) >> 2)\
| ((PING & (1<<5)) >> 1)\
| ((PINE & (1<<3)) << 2)\
| ((PINH & (3<<3)) << 3)\
)
#endif
#define setWriteDir() { DDRH |= HMASK; DDRG |= GMASK; DDRF |= FMASK; DDRE |= EMASK; }
#define setReadDir() { DDRH &= ~HMASK; DDRG &= ~GMASK; DDRF &= ~FMASK; DDRE &= ~EMASK; }
#define write8(x) { write_8(x); WR_STROBE; }
#define write16(x) { uint8_t h = (x)>>8, l = x; write8(h); write8(l); }
#define READ_8(dst) { RD_STROBE; dst = read_8(); RD_IDLE; }
#define READ_16(dst) { RD_STROBE; dst = read_8(); RD_IDLE; RD_STROBE; dst = (dst<<8) | read_8(); RD_IDLE; }
#define PIN_LOW(p, b) (p) &= ~(1<<(b))
#define PIN_HIGH(p, b) (p) |= (1<<(b))
#define PIN_OUTPUT(p, b) *(&p-1) |= (1<<(b))
#elif defined(__SAM3X8E__) && defined(USE_SSD1289_SHIELD_DUE) // on DUE
#warning USE_SSD1289_SHIELD_DUE
// configure macros for the control pins
#define RD_PORT PIOA
#define RD_PIN 22 //A3
#define WR_PORT PIOA
#define WR_PIN 23 //A2
#define CD_PORT PIOA
#define CD_PIN 24 //A1
#define CS_PORT PIOA
#define CS_PIN 16 //A0
#define RESET_PORT PIOC
#define RESET_PIN 21 //D9 Touch CS
// configure macros for data bus
// only for SSD1289 data bus on D2..D9 UNTESTED
#if SSD1289_JUMPERS == 0
#warning no jumpers Switch #1=ON, #2=ON
#define AMASK (3<<8)
#define BMASK (1<<25)
#define CMASK (0xBC << 21)
#define write_8(x) { PIOA->PIO_CODR = AMASK; PIOB->PIO_CODR = BMASK; PIOC->PIO_CODR = CMASK; \
PIOA->PIO_SODR = (((x) & (1<<0)) << 8); \
PIOA->PIO_SODR = (((x) & (1<<1)) << 8); \
PIOB->PIO_SODR = (((x) & (1<<2)) << 23); \
PIOC->PIO_SODR = (((x) & (1<<3)) << 25); \
PIOC->PIO_SODR = (((x) & (1<<4)) << 22); \
PIOC->PIO_SODR = (((x) & (1<<5)) << 20); \
PIOC->PIO_SODR = (((x) & (1<<6)) << 18); \
PIOC->PIO_SODR = (((x) & (1<<7)) << 16); \
}
#define read_8() ( ((PIOA->PIO_PDSR & (1<<8)) >> 8)\
| ((PIOA->PIO_PDSR & (1<<9)) >> 8)\
| ((PIOB->PIO_PDSR & (1<<25)) >> 23)\
| ((PIOC->PIO_PDSR & (1<<28)) >> 25)\
| ((PIOC->PIO_PDSR & (1<<26)) >> 22)\
| ((PIOC->PIO_PDSR & (1<<25)) >> 20)\
| ((PIOC->PIO_PDSR & (1<<24)) >> 18)\
| ((PIOC->PIO_PDSR & (1<<23)) >> 16)\
)
#elif SSD1289_JUMPERS == 1
#warning jumper D0 to D8. Switch #1=ON, #2=OFF
#define AMASK (1<<9)
#define BMASK (1<<25)
#define CMASK (0xBE << 21)
#define write_8(x) { PIOA->PIO_CODR = AMASK; PIOB->PIO_CODR = BMASK; PIOC->PIO_CODR = CMASK; \
PIOC->PIO_SODR = (((x) & (1<<0)) << 22); \
PIOA->PIO_SODR = (((x) & (1<<1)) << 8); \
PIOB->PIO_SODR = (((x) & (1<<2)) << 23); \
PIOC->PIO_SODR = (((x) & (1<<3)) << 25); \
PIOC->PIO_SODR = (((x) & (1<<4)) << 22); \
PIOC->PIO_SODR = (((x) & (1<<5)) << 20); \
PIOC->PIO_SODR = (((x) & (1<<6)) << 18); \
PIOC->PIO_SODR = (((x) & (1<<7)) << 16); \
}
#define read_8() ( ((PIOC->PIO_PDSR & (1<<22)) >> 22)\
| ((PIOA->PIO_PDSR & (1<<9)) >> 8)\
| ((PIOB->PIO_PDSR & (1<<25)) >> 23)\
| ((PIOC->PIO_PDSR & (1<<28)) >> 25)\
| ((PIOC->PIO_PDSR & (1<<26)) >> 22)\
| ((PIOC->PIO_PDSR & (1<<25)) >> 20)\
| ((PIOC->PIO_PDSR & (1<<24)) >> 18)\
| ((PIOC->PIO_PDSR & (1<<23)) >> 16)\
)
#elif SSD1289_JUMPERS == 2
#warning jumper D0 to D8, D1 to A5. Switch #1=OFF, #2=OFF
#define AMASK (1<<4)
#define BMASK (1<<25)
#define CMASK (0xBE << 21)
#define write_8(x) { PIOA->PIO_CODR = AMASK; PIOB->PIO_CODR = BMASK; PIOC->PIO_CODR = CMASK; \
PIOC->PIO_SODR = (((x) & (1<<0)) << 22); \
PIOA->PIO_SODR = (((x) & (1<<1)) << 3); \
PIOB->PIO_SODR = (((x) & (1<<2)) << 23); \
PIOC->PIO_SODR = (((x) & (1<<3)) << 25); \
PIOC->PIO_SODR = (((x) & (1<<4)) << 22); \
PIOC->PIO_SODR = (((x) & (1<<5)) << 20); \
PIOC->PIO_SODR = (((x) & (1<<6)) << 18); \
PIOC->PIO_SODR = (((x) & (1<<7)) << 16); \
}
#define read_8() ( ((PIOC->PIO_PDSR & (1<<22)) >> 22)\
| ((PIOA->PIO_PDSR & (1<<4)) >> 3)\
| ((PIOB->PIO_PDSR & (1<<25)) >> 23)\
| ((PIOC->PIO_PDSR & (1<<28)) >> 25)\
| ((PIOC->PIO_PDSR & (1<<26)) >> 22)\
| ((PIOC->PIO_PDSR & (1<<25)) >> 20)\
| ((PIOC->PIO_PDSR & (1<<24)) >> 18)\
| ((PIOC->PIO_PDSR & (1<<23)) >> 16)\
)
#endif
#define setWriteDir() { PIOA->PIO_OER = AMASK; PIOB->PIO_OER = BMASK; PIOC->PIO_OER = CMASK; }
#define setReadDir() { \
PMC->PMC_PCER0 = (1 << ID_PIOA)|(1 << ID_PIOB)|(1 << ID_PIOC);\
PIOA->PIO_ODR = AMASK; PIOB->PIO_ODR = BMASK; PIOC->PIO_ODR = CMASK;\
}
#define write8(x) { write_8(x); WR_ACTIVE; WR_STROBE; WR_IDLE; }
#define write16(x) { uint8_t h = (x)>>8, l = x; write8(h); write8(l); }
#define READ_8(dst) { RD_STROBE; RD_ACTIVE4; dst = read_8(); RD_IDLE; RD_IDLE; RD_IDLE; }
#define READ_16(dst) { uint8_t hi; READ_8(hi); READ_8(dst); dst |= (hi << 8); }
// Shield Control macros.
#define PIN_LOW(port, pin) (port)->PIO_CODR = (1<<(pin))
#define PIN_HIGH(port, pin) (port)->PIO_SODR = (1<<(pin))
#define PIN_OUTPUT(port, pin) (port)->PIO_OER = (1<<(pin))
//##################################### USE_FRDM_K20 ###################################################
//#define USE_FRDM_K20
#elif defined(__MK20DX128__) && defined(USE_FRDM_K20) // Uno Shield on FRDM-K20
#warning Uno Shield on FRDM-K20
#define RD_PORT GPIOC
#define RD_PIN 0
#define WR_PORT GPIOC
#define WR_PIN 1
#define CD_PORT GPIOD
#define CD_PIN 6
#define CS_PORT GPIOD
#define CS_PIN 5
#define RESET_PORT GPIOB
#define RESET_PIN 1
// configure macros for the data pins
#define AMASK ((1<<12)|(1<<5)|(1<<2)|(1<<1))
#define CMASK ((1<<8)|(1<<4)|(1<<3))
#define DMASK ((1<<4))
#define write_8(d) { \
GPIOA_PCOR = AMASK; GPIOC_PCOR = CMASK; GPIOD_PCOR = DMASK; \
GPIOA_PSOR = (((d) & (1<<0)) << 12) \
| (((d) & (1<<1)) << 1) \
| (((d) & (1<<2)) << 3) \
| (((d) & (1<<5)) >> 4); \
GPIOC_PSOR = (((d) & (1<<4)) << 4) \
| (((d) & (3<<6)) >> 3); \
GPIOD_PSOR = (((d) & (1<<3)) << 1); \
}
#define read_8() ( (((GPIOA_PDIR & (1<<5)) >> 3) \
| ((GPIOA_PDIR & (1<<1)) << 4) \
| ((GPIOA_PDIR & (1<<12)) >> 12) \
| ((GPIOA_PDIR & (1<<2)) >> 1) \
| ((GPIOC_PDIR & (1<<8)) >> 4) \
| ((GPIOC_PDIR & (3<<3)) << 3) \
| ((GPIOD_PDIR & (1<<4)) >> 1)))
#define setWriteDir() {GPIOA_PDDR |= AMASK;GPIOC_PDDR |= CMASK;GPIOD_PDDR |= DMASK; }
#define setReadDir() {GPIOA_PDDR &= ~AMASK;GPIOC_PDDR &= ~CMASK;GPIOD_PDDR &= ~DMASK; }
#define write8(x) { write_8(x); WR_ACTIVE2; WR_STROBE; }
#define write16(x) { uint8_t h = (x)>>8, l = x; write8(h); write8(l); }
#define READ_8(dst) { RD_STROBE; RD_ACTIVE4; RD_ACTIVE; dst = read_8(); RD_IDLE; }
#define READ_16(dst) { uint8_t hi; READ_8(hi); READ_8(dst); dst |= (hi << 8); }
#define PASTE(x, y) x ## y
#define PIN_LOW(port, pin) PASTE(port, _PCOR) = (1<<(pin))
#define PIN_HIGH(port, pin) PASTE(port, _PSOR) = (1<<(pin))
#define PIN_OUTPUT(port, pin) PASTE(port, _PDDR) |= (1<<(pin))
//####################################### D21_XPRO ###########################################################
#elif defined(__SAMD21J18A__) //regular UNO shield on D21_XPRO
#warning regular UNO shield on D21_XPRO
#include "samd21.h"
// configure macros for the control pins
#define RD_PORT PORT->Group[1]
#define RD_PIN 0
#define WR_PORT PORT->Group[1]
#define WR_PIN 1
#define CD_PORT PORT->Group[0]
#define CD_PIN 10
#define CS_PORT PORT->Group[0]
#define CS_PIN 11
#define RESET_PORT PORT->Group[0]
#define RESET_PIN 8
// configure macros for data bus
#define AMASK 0x00220000
#define BMASK 0x0000C0E4
#define write_8(d) { \
PORT->Group[0].OUT.reg = (PORT->Group[0].OUT.reg & ~AMASK) \
| (((d) & (1<<5)) << 16) \
| (((d) & (1<<7)) << 10); \
PORT->Group[1].OUT.reg = (PORT->Group[1].OUT.reg & ~BMASK) \
| (((d) & (3<<0)) << 6) \
| (((d) & (1<<2)) << 12) \
| (((d) & (1<<3)) >> 1) \
| (((d) & (1<<4)) << 1) \
| (((d) & (1<<6)) << 9); \
}
#define read_8() ( (((PORT->Group[0].IN.reg & (1<<21)) >> 16) \
| ((PORT->Group[0].IN.reg & (1<<17)) >> 10) \
| ((PORT->Group[1].IN.reg & (3<<6)) >> 6) \
| ((PORT->Group[1].IN.reg & (1<<14)) >> 12) \
| ((PORT->Group[1].IN.reg & (1<<2)) << 1) \
| ((PORT->Group[1].IN.reg & (1<<5)) >> 1) \
| ((PORT->Group[1].IN.reg & (1<<15)) >> 9)))
#define setWriteDir() { \
PORT->Group[0].DIRSET.reg = AMASK; \
PORT->Group[1].DIRSET.reg = BMASK; \
PORT->Group[0].WRCONFIG.reg = (AMASK>>16) | (0<<22) | (0<<28) | (1<<30) | (1<<31); \
PORT->Group[1].WRCONFIG.reg = (BMASK & 0xFFFF) | (0<<22) | (0<<28) | (1<<30); \
}
#define setReadDir() { \
PORT->Group[0].DIRCLR.reg = AMASK; \
PORT->Group[1].DIRCLR.reg = BMASK; \
PORT->Group[0].WRCONFIG.reg = (AMASK>>16) | (1<<17) | (0<<28) | (1<<30) | (1<<31); \
PORT->Group[1].WRCONFIG.reg = (BMASK & 0xFFFF) | (1<<17) | (0<<28) | (1<<30); \
}
#define write8(x) { write_8(x); WR_STROBE; }
#define write16(x) { uint8_t h = (x)>>8, l = x; write8(h); write8(l); }
#define READ_8(dst) { RD_STROBE; dst = read_8(); RD_IDLE; }
#define READ_16(dst) { RD_STROBE; dst = read_8(); RD_IDLE; RD_STROBE; dst = (dst<<8) | read_8(); RD_IDLE; }
// Shield Control macros.
#define PIN_LOW(port, pin) (port).OUTCLR.reg = (1<<(pin))
#define PIN_HIGH(port, pin) (port).OUTSET.reg = (1<<(pin))
#define PIN_OUTPUT(port, pin) (port).DIR.reg |= (1<<(pin))
//###################################### TEENSY 4 BETA ####################################
#elif defined(__IMXRT1052__)// regular UNO shield on a Teensy 4.x
#warning regular UNO shield on UNKNOWN Teensy 4.0
//LCD pins |D7 |D6 |D5 |D4 |D3 |D2 |D1 |D0 | |RD |WR |RS |CS |RST | A5
//MXRT pin |4.16|4.17|2.7|2.6|2.5|2.4|4.11|4.10| |1.18|1.19|1.23|1.22|1.17|1.16
#if 0
#elif defined(__IMXRT1052__)
#define WRITE_DELAY { WR_ACTIVE8;WR_ACTIVE8; }
#define IDLE_DELAY { WR_IDLE2;WR_IDLE; }
#define READ_DELAY { RD_ACTIVE16;RD_ACTIVE16; }
#else
#error unspecified delays
#endif
#define RD_PORT GPIO1
#define RD_PIN 18
#define WR_PORT GPIO1
#define WR_PIN 19
#define CD_PORT GPIO1
#define CD_PIN 23
#define CS_PORT GPIO1
#define CS_PIN 22
#define RESET_PORT GPIO1
#define RESET_PIN 17
// configure macros for the data pins
#define DMASK ((1<<16)|(1<<17)|(1<<11)|(1<<10))
#define BMASK ((1<<7)|(1<<6)|(1<<5)|(1<<4))
#define write_8(d) { \
GPIO4_DR_CLEAR = DMASK; GPIO2_DR_CLEAR = BMASK; \
GPIO4_DR_SET = (((d) & (1 << 0)) << 10) \
| (((d) & (1 << 1)) << 10) \
| (((d) & (1 << 6)) << 11) \
| (((d) & (1 << 7)) << 9); \
GPIO2_DR_SET = (((d) & (1 << 2)) << 2) \
| (((d) & (1 << 3)) << 2) \
| (((d) & (1 << 4)) << 2) \
| (((d) & (1 << 5)) << 2); \
}
#define read_8() ((((GPIO4_PSR & (1 << 10)) >> 10) \
| ((GPIO4_PSR & (1 << 11)) >> 10) \
| ((GPIO2_PSR & (1 << 4)) >> 2) \
| ((GPIO2_PSR & (1 << 5)) >> 2) \
| ((GPIO2_PSR & (1 << 6)) >> 2) \
| ((GPIO2_PSR & (1 << 7)) >> 2) \
| ((GPIO4_PSR & (1 << 17)) >> 11) \
| ((GPIO4_PSR & (1 << 16)) >> 9)))
#define setWriteDir() {GPIO4_GDIR |= DMASK;GPIO2_GDIR |= BMASK; }
#define setReadDir() {GPIO4_GDIR &= ~DMASK;GPIO2_GDIR &= ~BMASK; }
#define write8(x) { write_8(x); WRITE_DELAY; WR_STROBE; IDLE_DELAY; }
#define write16(x) { uint8_t h = (x)>>8, l = x; write8(h); write8(l); }
#define READ_8(dst) { RD_STROBE; READ_DELAY; dst = read_8(); RD_IDLE2; RD_IDLE; }
#define READ_16(dst) { uint8_t hi; READ_8(hi); READ_8(dst); dst |= (hi << 8); }
#define GPIO_INIT() {for (int i = 2; i <= 9; i++) pinMode(i, OUTPUT); for (int i = A0; i <= A4; i++) pinMode(i, OUTPUT);}
#define PASTE(x, y) x ## y
#define PIN_LOW(port, pin) PASTE(port, _DR_CLEAR) = (1<<(pin))
#define PIN_HIGH(port, pin) PASTE(port, _DR_SET) = (1<<(pin))
#define PIN_OUTPUT(port, pin) PASTE(port, _GDIR) |= (1<<(pin))
//####################################### NANO IOT 33 ############################
#elif defined(__SAMD21G18A__) && defined(ARDUINO_SAMD_NANO_33_IOT) //regular UNO shield on NANO IOT 33
#warning building for NANO IOT 33
//LCD pins |D7 |D6 |D5 |D4 |D3 |D2 |D1 |D0 | |RD |WR |RS |CS |RST |
//SAMD21 pin |PA6 |PA4 |PA5 |PA7 |PB11|PB10|PA20|PA18| |PA2|PB2|PA11|PA10|PB08|
#define WRITE_DELAY { WR_ACTIVE4; }
#define IDLE_DELAY { WR_IDLE2; }
#define READ_DELAY { RD_ACTIVE8;}
// configure macros for the control pins
#define RD_PORT PORT->Group[0] //PA02
#define RD_PIN 2
#define WR_PORT PORT->Group[1] //PB02
#define WR_PIN 2
#define CD_PORT PORT->Group[0] //PA11
#define CD_PIN 11
#define CS_PORT PORT->Group[0] //PA10
#define CS_PIN 10
#define RESET_PORT PORT->Group[1] //PB08
#define RESET_PIN 8
// configure macros for data bus
#define AMASK ((15<<4)|(1<<18)|(1<<20))
#define BMASK (3<<10) //
#define WRMASK ((0<<22) | (1<<28) | (1<<30)) //
#define RDMASK ((1<<17) | (1<<28) | (1<<30)) //
#define write_8(x) { \
PORT->Group[0].OUTCLR.reg = AMASK; PORT->Group[1].OUTCLR.reg = BMASK; \
PORT->Group[0].OUTSET.reg = \
(((x) & (1<<0)) << 18) | (((x) & (1<<1)) << 19) | \
(((x) & (1<<4)) << 3) | (((x) & (1<<5)) << 0) | \
(((x) & (1<<6)) >> 2) | (((x) & (1<<7)) >> 1); \
PORT->Group[1].OUTSET.reg = (((x) & (3<<2)) << 8); \
}
#define read_8() ( \
((PORT->Group[0].IN.reg & (1<<18)) >> 18)\
| ((PORT->Group[0].IN.reg & (1<<20)) >> 19)\
| ((PORT->Group[0].IN.reg & (1<<7)) >> 3)\
| ((PORT->Group[0].IN.reg & (1<<5)) >> 0)\
| ((PORT->Group[0].IN.reg & (1<<4)) << 2)\
| ((PORT->Group[0].IN.reg & (1<<6)) << 1)\
| ((PORT->Group[1].IN.reg & (3<<10)) >> 8)\
)
#define setWriteDir() { \
PORT->Group[0].DIRSET.reg = AMASK; \
PORT->Group[0].WRCONFIG.reg = (AMASK & 0xFFFF) | WRMASK; \
PORT->Group[1].DIRSET.reg = BMASK; \
PORT->Group[1].WRCONFIG.reg = (BMASK & 0xFFFF) | WRMASK; \
}
#define setReadDir() { \
PORT->Group[0].DIRCLR.reg = AMASK; \
PORT->Group[0].WRCONFIG.reg = (AMASK & 0xFFFF) | RDMASK; \
PORT->Group[1].DIRCLR.reg = BMASK; \
PORT->Group[1].WRCONFIG.reg = (BMASK & 0xFFFF) | RDMASK; \
}
#define write8(x) { write_8(x); WRITE_DELAY; WR_STROBE; IDLE_DELAY; }
#define write16(x) { uint8_t h = (x)>>8, l = x; write8(h); write8(l); }
#define READ_8(dst) { RD_STROBE; READ_DELAY; dst = read_8(); RD_IDLE2; RD_IDLE; }
#define READ_16(dst) { uint8_t hi; READ_8(hi); READ_8(dst); dst |= (hi << 8); }
// Shield Control macros.
#define PIN_LOW(port, pin) (port).OUTCLR.reg = (1<<(pin))
#define PIN_HIGH(port, pin) (port).OUTSET.reg = (1<<(pin))
#define PIN_OUTPUT(port, pin) (port).DIRSET.reg = (1<<(pin))
//#################################################################################################################
libraries/MCUFRIEND_kbv/extras/unused/mcufriend_special_4.h
+188
View File
@@ -0,0 +1,188 @@
#define SSD1289_JUMPERS 2 //Uno Shield with VERY different pin-out to Mcufriend
//#define USE_SSD1289_SHIELD_UNO
//#define USE_SSD1289_SHIELD_MEGA
#define USE_SSD1289_SHIELD_DUE //Due only works with JUMPERS==2
#if 0
//################################# SSD1289 SHIELD #######################
// SSD1289 shield has LCD_D0 on RXD0. SD_CS=D8, T_IRQ=D9, T_CS=D10
// This is fine for write-only operations with NO Serial. A4, A5 are available for I2C
// NOTE THAT Serial.end() IS REQUIRED FOR NO JUMPERS
// Read operations, lose I2C (on Uno) but gain Serial, Bootloader etc
// jumper D0 to A4, D1 to A5, Switch #1 to OFF, #2 to OFF
#elif defined(__AVR_ATmega328P__) && defined(USE_SSD1289_SHIELD_UNO) //on UNO
#warning using SSD1289 Shield for mega328
#define RD_PORT PORTC
#define RD_PIN 3
#define WR_PORT PORTC
#define WR_PIN 2
#define CD_PORT PORTC
#define CD_PIN 1
#define CS_PORT PORTC
#define CS_PIN 0
#define RESET_PORT PORTB
#define RESET_PIN 1 //D9 actually T_IRQ
#if SSD1289_JUMPERS == 0 //data bus on D0..D7
#warning no jumpers. Switch #1=ON, #2=ON
#define BMASK 0x00 //0x00 for output, 0x01 for Read + Serial
#define CMASK 0x00 //0x20 for Read + Serial
#define DMASK 0xFF
#define write8(x) { PORTD = x; WR_STROBE; }
#define read_8() ( 0xAB ) //this shield is WRITE-ONLY
#elif SSD1289_JUMPERS == 2
#warning jumper D0 to A4, D1 to A5. Switch #1=OFF, #2=OFF
#define BMASK 0x00 //D8 is unused now
#define CMASK ((1<<4)|(1<<5)) //A4, A5
#define DMASK (0xFC)
#define write8(x) { PORTC = (PORTC & ~CMASK) | ((x<<4) & CMASK);\
PORTD = (PORTD & ~DMASK) | (x & DMASK); WR_STROBE; }
#define read_8() ( ((PINC & CMASK)>>4)|(PIND & DMASK) )
#endif
#define setWriteDir() { DDRC |= CMASK; DDRD |= DMASK; DDRB |= BMASK; }
#define setReadDir() { DDRC &= ~CMASK; DDRD &= ~DMASK; DDRB &= ~BMASK; }
#define write16(x) { uint8_t h = (x)>>8, l = x; write8(h); write8(l); }
#define READ_8(dst) { RD_STROBE; dst = read_8(); RD_IDLE; }
#define READ_16(dst) { uint8_t hi; READ_8(hi); READ_8(dst); dst |= (hi << 8); }
#define PIN_LOW(p, b) (p) &= ~(1<<(b))
#define PIN_HIGH(p, b) (p) |= (1<<(b))
#define PIN_OUTPUT(p, b) *(&p-1) |= (1<<(b))
#elif defined(__AVR_ATmega2560__) && defined(USE_SSD1289_SHIELD_MEGA)
#warning using SSD1289 Shield for mega2560
#define RD_PORT PORTF
#define RD_PIN 3 //A3
#define WR_PORT PORTF
#define WR_PIN 2 //A2
#define CD_PORT PORTF
#define CD_PIN 1 //A1
#define CS_PORT PORTF
#define CS_PIN 0 //A0
#define RESET_PORT PORTH
#define RESET_PIN 6 //D9 (D10=T_CS, D9=T_IRQ, D8=SD_CS)
#if (SSD1289_JUMPERS == 0) //data bus on D0..D7
#warning no jumpers Switch #1=ON, #2=ON
#define EMASK ((1<<0)|(1<<1)|(1<<4)|(1<<5)|(1<<3))
#define FMASK 0x00
#define HMASK ((1<<3)|(1<<4))
#define GMASK (1<<5)
#define write_8(x) { PORTH &= ~HMASK; PORTG &= ~GMASK; PORTF &= ~FMASK; PORTE &= ~EMASK; \
PORTE |= (((x) & (1<<0)) << 0); \
PORTE |= (((x) & (1<<1)) << 0); \
PORTE |= (((x) & (3<<2)) << 2); \
PORTG |= (((x) & (1<<4)) << 1); \
PORTE |= (((x) & (1<<5)) >> 2); \
PORTH |= (((x) & (3<<6)) >> 3); \
}
#define read_8() ( 0xBC ) //this shield is WRITE-ONLY
#elif (SSD1289_JUMPERS == 2) //jumper D0 to A4, D1 to A5. Switch #1=OFF, #2=OFF
#warning jumper D0 to A4, D1 to A5. Switch #1=OFF, #2=OFF
#define EMASK ((1<<4)|(1<<5)|(1<<3))
#define FMASK ((1<<4)|(1<<5))
#define HMASK ((1<<3)|(1<<4))
#define GMASK (1<<5)
#define write_8(x) { PORTH &= ~HMASK; PORTG &= ~GMASK; PORTF &= ~FMASK; PORTE &= ~EMASK; \
PORTF |= (((x) & (1<<0)) << 4); \
PORTF |= (((x) & (1<<1)) << 4); \
PORTE |= (((x) & (3<<2)) << 2); \
PORTG |= (((x) & (1<<4)) << 1); \
PORTE |= (((x) & (1<<5)) >> 2); \
PORTH |= (((x) & (3<<6)) >> 3); \
}
#define read_8() ( ((PINF & (1<<4)) >> 4)\
| ((PINF & (1<<5)) >> 4)\
| ((PINE & (3<<4)) >> 2)\
| ((PING & (1<<5)) >> 1)\
| ((PINE & (1<<3)) << 2)\
| ((PINH & (3<<3)) << 3)\
)
#endif
#define setWriteDir() { DDRH |= HMASK; DDRG |= GMASK; DDRF |= FMASK; DDRE |= EMASK; }
#define setReadDir() { DDRH &= ~HMASK; DDRG &= ~GMASK; DDRF &= ~FMASK; DDRE &= ~EMASK; }
#define write8(x) { write_8(x); WR_STROBE; }
#define write16(x) { uint8_t h = (x)>>8, l = x; write8(h); write8(l); }
#define READ_8(dst) { RD_STROBE; dst = read_8(); RD_IDLE; }
#define READ_16(dst) { RD_STROBE; dst = read_8(); RD_IDLE; RD_STROBE; dst = (dst<<8) | read_8(); RD_IDLE; }
#define PIN_LOW(p, b) (p) &= ~(1<<(b))
#define PIN_HIGH(p, b) (p) |= (1<<(b))
#define PIN_OUTPUT(p, b) *(&p-1) |= (1<<(b))
#elif defined(__SAM3X8E__) && defined(USE_SSD1289_SHIELD_DUE) // on DUE
#warning USE_SSD1289_SHIELD_DUE
// configure macros for the control pins
#define RD_PORT PIOA
#define RD_PIN 22 //A3
#define WR_PORT PIOA
#define WR_PIN 23 //A2
#define CD_PORT PIOA
#define CD_PIN 24 //A1
#define CS_PORT PIOA
#define CS_PIN 16 //A0
#define RESET_PORT PIOC
#define RESET_PIN 21 //D9 Touch_IRQ
// configure macros for data bus
#if SSD1289_JUMPERS == 0 //data bus on D0..D7
#warning no jumpers Switch #1=ON, #2=ON
#define AMASK ((1<<8)|(1<<9)) //D0, D1
#define BMASK (1<<25)
#define CMASK ((1<<28)|(1<<26)|(1<<25)|(1<<24)|(1<<23))
#define write_8(x) { PIOA->PIO_CODR = AMASK; PIOB->PIO_CODR = BMASK; PIOC->PIO_CODR = CMASK; \
PIOA->PIO_SODR = (((x) & (1<<0)) << 8); \
PIOA->PIO_SODR = (((x) & (1<<1)) << 8); \
PIOB->PIO_SODR = (((x) & (1<<2)) << 23); \
PIOC->PIO_SODR = (((x) & (1<<3)) << 25); \
PIOC->PIO_SODR = (((x) & (1<<4)) << 22); \
PIOC->PIO_SODR = (((x) & (1<<5)) << 20); \
PIOC->PIO_SODR = (((x) & (1<<6)) << 18); \
PIOC->PIO_SODR = (((x) & (1<<7)) << 16); \
}
#define read_8() ( 0xCD ) //this shield is WRITE-ONLY
#elif SSD1289_JUMPERS == 2 //jumper D0 to A4, D1 to A5. Switch #1=OFF, #2=OFF
#warning jumper D0 to A4, D1 to A5. Switch #1=OFF, #2=OFF
#define AMASK ((1<<6)|(1<<4)) //A4, A5
#define BMASK (1<<25)
#define CMASK ((1<<28)|(1<<26)|(1<<25)|(1<<24)|(1<<23))
#define write_8(x) { PIOA->PIO_CODR = AMASK; PIOB->PIO_CODR = BMASK; PIOC->PIO_CODR = CMASK; \
PIOA->PIO_SODR = (((x) & (1<<0)) << 6); \
PIOA->PIO_SODR = (((x) & (1<<1)) << 3); \
PIOB->PIO_SODR = (((x) & (1<<2)) << 23); \
PIOC->PIO_SODR = (((x) & (1<<3)) << 25); \
PIOC->PIO_SODR = (((x) & (1<<4)) << 22); \
PIOC->PIO_SODR = (((x) & (1<<5)) << 20); \
PIOC->PIO_SODR = (((x) & (1<<6)) << 18); \
PIOC->PIO_SODR = (((x) & (1<<7)) << 16); \
}
#define read_8() ( ((PIOA->PIO_PDSR & (1<<6)) >> 6)\
| ((PIOA->PIO_PDSR & (1<<4)) >> 3)\
| ((PIOB->PIO_PDSR & (1<<25)) >> 23)\
| ((PIOC->PIO_PDSR & (1<<28)) >> 25)\
| ((PIOC->PIO_PDSR & (1<<26)) >> 22)\
| ((PIOC->PIO_PDSR & (1<<25)) >> 20)\
| ((PIOC->PIO_PDSR & (1<<24)) >> 18)\
| ((PIOC->PIO_PDSR & (1<<23)) >> 16)\
)
#endif
#define setWriteDir() { PIOA->PIO_OER = AMASK; PIOB->PIO_OER = BMASK; PIOC->PIO_OER = CMASK; }
#define setReadDir() { \
PMC->PMC_PCER0 = (1 << ID_PIOA)|(1 << ID_PIOB)|(1 << ID_PIOC);\
PIOA->PIO_ODR = AMASK; PIOB->PIO_ODR = BMASK; PIOC->PIO_ODR = CMASK;\
}
#define write8(x) { write_8(x); WR_ACTIVE; WR_STROBE; WR_IDLE; }
#define write16(x) { uint8_t h = (x)>>8, l = x; write8(h); write8(l); }
#define READ_8(dst) { RD_STROBE; RD_ACTIVE4; dst = read_8(); RD_IDLE; RD_IDLE; RD_IDLE; }
#define READ_16(dst) { uint8_t hi; READ_8(hi); READ_8(dst); dst |= (hi << 8); }
// Shield Control macros.
#define PIN_LOW(port, pin) (port)->PIO_CODR = (1<<(pin))
#define PIN_HIGH(port, pin) (port)->PIO_SODR = (1<<(pin))
#define PIN_OUTPUT(port, pin) (port)->PIO_OER = (1<<(pin))
libraries/MCUFRIEND_kbv/extras/unused/pagebreak.sed
+21
View File
@@ -0,0 +1,21 @@
# skip the Ilitek PDF page footers.
/^a-.*/,/^Page.*/d
# skip the GalaxyCore PDF page headers.
/^Page*/,/^132RGB.*/d
# GalaxyCore //comment// to //comment
s/----\/\/$/----/
# skip the Himax PDF page footers.
/^Him.ax Confidential*/,/^APPLICATION NOTE/d
/^-P.*Himax Confidential*/,/^APPLICATION NOTE/d
# skip the Renesas PDF page footers.
/^[0-9]+$/,/Renesas SP Drivers/d
#/Initial Code(/d
# comment the Panel Title
s/^[1-9]/\/\/ &/
# remove Enter/Exit Sleep functions
/^[Vv]oid.*Sleep/,/^}/d
/^[Vv]oid.*Standby/,/^}/d
# legal function name
/^void/s/[.]//
# remove hardware Reset sequence
/Reset LCD Driver/,/Start Initial Sequence/d
libraries/MCUFRIEND_kbv/extras/unused/r61526_init.h
+279
View File
@@ -0,0 +1,279 @@
/* 2. HSD 2.2” Gamma 2.2 Initial Code(1/2)*/
/*R61526 for Hannstar 2.2" Gamma 2.2*/
(0xB0), 0x3F, 0x3F,
TFTLCD_DELAY8, 5,
(0xB3), 0x02, 0x00, 0x00, 0x00, 0x00,
(0xB4), 0x00,
(0xC0), 0x33, 0x4F, 0x00, 0x10, 0xA2, 0x00, 0x01, 0x00,
(0xC1), 0x01, 0x02, 0x1B, 0x08, 0x08,
TFTLCD_DELAY8, 25,
(0xC3), 0x01, 0x00, 0x1B, 0x08, 0x08,
TFTLCD_DELAY8, 25,
(0xC4), 0x21, 0x01, 0x200, 0x02, 0x00,
/*Gamma setting start*/
(0xC8), 0x09, 0x09, 0x0B, 0x0B, 0x0F, 0x00, 0x00, 0x06, 0x15, 0x13, 0x00, 0x03, 0x08, 0x07, 0x0E, 0x0E, 0x1D, 0x0B, 0x11, 0x0C, 0x0C, 0x03,
(0xC9), 0x09, 0x09, 0x0B, 0x0B, 0x0F, 0x00, 0x00, 0x06, 0x15, 0x13, 0x00, 0x03, 0x08, 0x07, 0x0E, 0x0E, 0x1D, 0x0B, 0x11, 0x0C, 0x0C, 0x03,
/* 2. HSD 2.2” Gamma 2.2 Initial Code(2/2)*/
(0xCA), 0x09, 0x09, 0x0B, 0x0B, 0x0F, 0x00, 0x00, 0x06, 0x15, 0x13, 0x00, 0x03, 0x08, 0x07, 0x0E, 0x0E, 0x1D, 0x0B, 0x11, 0x0C, 0x0C, 0x03,
/*Gamma setting end*/
/*Power setting start*/
(0xD0), 0x33, 0x53, 0x85, 0x35, 0x00, 0x00,
(0xD1), 0x53, 0x7A, 0x10,
(0xD2), 0x03, 0x24,
(0xD4), 0x03, 0x24,
(0xE2), 0x3F,
/*Power setting End*/
/*Other setting*/
(0x35), 0x00,
(0x36), 0x00,
(0x3A), 0x66,
(0x2A), 0x00, 0x00, 0x00, 0xEF,
(0x2B), 0x00, 0x00, 0x01, 0x3F,
(0x2C),
(0x11),
TFTLCD_DELAY8, 30,
(0x29),
/*End Gamma 2.2 Setting*/
/* 2. HSD 2.2” Gamma 2.5 Initial Code(1/2)*/
/*R61526 for Hannstar 2.2" Gamma 2.5*/
(0xB0), 0x3F, 0x3F,
TFTLCD_DELAY8, 5,
(0xB3), 0x02, 0x00, 0x00, 0x00, 0x00,
(0xB4), 0x00,
(0xC0), 0x33, 0x4F, 0x00, 0x10, 0xA2, 0x00, 0x01, 0x00,
(0xC1), 0x01, 0x02, 0x1B, 0x08, 0x08,
TFTLCD_DELAY8, 25,
(0xC3), 0x01, 0x00, 0x1B, 0x08, 0x08,
TFTLCD_DELAY8, 25,
(0xC4), 0x21, 0x01, 0x300, 0x02, 0x00,
/*Gamma setting start*/
(0xC8), 0x09, 0x09, 0x0B, 0x10, 0x09, 0x01, 0x03, 0x0A, 0x1F, 0x06, 0x00, 0x03, 0x08, 0x07, 0x0E, 0x14, 0x18, 0x0A, 0x11, 0x0C, 0x0C, 0x03,
(0xC9), 0x09, 0x09, 0x0B, 0x10, 0x09, 0x01, 0x03, 0x0A, 0x1F, 0x06, 0x00, 0x03, 0x08, 0x07, 0x0E, 0x14, 0x18, 0x0A, 0x11, 0x0C, 0x0C, 0x03,
/* 2. HSD 2.2” Gamma 2.5 Initial Code(2/2)*/
(0xCA), 0x09, 0x09, 0x0B, 0x10, 0x09, 0x01, 0x03, 0x0A, 0x1F, 0x06, 0x00, 0x03, 0x08, 0x07, 0x0E, 0x14, 0x18, 0x0A, 0x11, 0x0C, 0x0C, 0x03,
/*Gamma setting end*/
/*Power setting start*/
(0xD0), 0x33, 0x53, 0x85, 0x35, 0x00, 0x00,
(0xD1), 0x54, /*VCM 1B~7F*/ 0x7A, /*VDV 25~7F*/ 0x10,
(0xD2), 0x03, 0x24,
(0xD4), 0x03, 0x24,
(0xE2), 0x3F,
/*Power setting End*/
/*Other setting*/
(0x35), 0x00,
(0x36), 0x00,
(0x3A), 0x66, /*66->18 bit, 55->16bit.*/
(0x2A), 0x00, 0x00, 0x00, 0xEF,
(0x2B), 0x00, 0x00, 0x01, 0x3F,
(0x2C),
(0x11),
TFTLCD_DELAY8, 30,
(0x29),
(0xB0), 0x3F, 0x3F,
(0xFE), 0x00, 0x00, 0x00, 0x21, 0xB4,
(0xB3), 0x00, 0x10,
(0xE0), 0x00, 0x40,
TFTLCD_DELAY8, 5 ,
(0xB3), 0x00, 0x00,
(0xFE), 0x00, 0x00, 0x00, 0x21, 0x30,
(0xB0), 0x3F, 0x3F,
(0xB3), 0x02, 0x00, 0x00, 0x00,
(0xB4), 0x00,
(0xC0), 0x03, 0x4F, 0x00, 0x10, 0xA2, 0x00, 0x01, 0x00,
(0xC1), 0x01, 0x02, 0x28, 0x08, 0x08,
TFTLCD_DELAY8, 25 ,
(0xC3), 0x01, 0x00, 0x28, 0x08, 0x08,
TFTLCD_DELAY8, 25 ,
(0xC4), 0x11, 0x01, 0x00, 0x00,
(0xC8), /*Gamma*/ 0x0C, 0x0C, 0x0D, 0x14, 0x18, 0x0E, 0x09, 0x09, 0x03, 0x05, 0x00, 0x03, 0x08, 0x07, 0x0E, 0x15, 0x12, 0x0A, 0x0E, 0x0A, 0x0A, 0x00,
/* 3. LGD 2.6” Gamma 2.2 Initial Code(1/2)*/
(0xC9), /*Gamma*/ 0x0C, 0x0C, 0x0D, 0x14, 0x18, 0x0E, 0x09, 0x09, 0x03, 0x05, 0x00, 0x03, 0x08, 0x07, 0x0E, 0x15, 0x12, 0x0A, 0x0E, 0x0A, 0x0A, 0x00,
(0xCA), /*Gamma*/ 0x0C, 0x0C, 0x0D, 0x14, 0x18, 0x0E, 0x09, 0x09, 0x03, 0x05, 0x00, 0x03, 0x08, 0x07, 0x0E, 0x15, 0x12, 0x0A, 0x0E, 0x0A, 0x0A, 0x00,
(0xD0), 0x63, 0x53, 0x82, 0x3F,
(0xD1), 0x6A, 0x64,
(0xD2), 0x03, 0x24,
(0xD4), 0x03, 0x24,
(0xE2), 0x3F,
(0x35), 0x00,
(0x36), 0x00,
(0x3A), 0x55,
(0x2A), 0x00, 0x00, 0x00, 0xEF,
(0x2B), 0x00, 0x00, 0x01, 0x3F,
(0x2C),
(0x11),
TFTLCD_DELAY8, 40 ,
(0x29),
(0x2C),
/* 3. LGD 2.6” Gamma 2.2 Initial Code(2/2)*/
(0xB0), 0x3F, 0x3F,
(0xFE), 0x00, 0x00, 0x00, 0x21, 0xB4,
(0xB3), 0x00, 0x10,
(0xE0), 0x00, 0x40,
TFTLCD_DELAY8, 5 ,
(0xB3), 0x00, 0x00,
(0xFE), 0x00, 0x00, 0x00, 0x21, 0x30,
(0xB0), 0x3F, 0x3F,
(0xB3), 0x02, 0x00, 0x00, 0x00,
(0xB4), 0x00,
(0xC0), 0x03, 0x4F, 0x00, 0x10, 0xA2, 0x00, 0x01, 0x00,
(0xC1), 0x01, 0x02, 0x28, 0x08, 0x08,
TFTLCD_DELAY8, 25 ,
(0xC3), 0x01, 0x00, 0x28, 0x08, 0x08,
TFTLCD_DELAY8, 25 ,
(0xC4), 0x11, 0x01, 0x00, 0x00,
(0xC8), /*Gamma*/ 0x09, 0x09, 0x0B, 0x13, 0x16, 0x0C, 0x09, 0x09, 0x03, 0x05, 0x00, 0x03, 0x08, 0x07, 0x0E, 0x15, 0x12, 0x09, 0x0D, 0x0C, 0x0C, 0x03,
/* 3. LGD 2.6” Gamma 2.5 Initial Code(1/2)*/
(0xC9), /*Gamma*/ 0x09, 0x09, 0x0B, 0x13, 0x16, 0x0C, 0x09, 0x09, 0x03, 0x05, 0x00, 0x03, 0x08, 0x07, 0x0E, 0x15, 0x12, 0x09, 0x0D, 0x0C, 0x0C, 0x03,
(0xCA), /*Gamma*/ 0x09, 0x09, 0x0B, 0x13, 0x16, 0x0C, 0x09, 0x09, 0x03, 0x05, 0x00, 0x03, 0x08, 0x07, 0x0E, 0x15, 0x12, 0x09, 0x0D, 0x0C, 0x0C, 0x03,
(0xD0), 0x63, 0x53, 0x82, 0x3F,
(0xD1), 0x6A, 0x64,
(0xD2), 0x03, 0x24,
(0xD4), 0x03, 0x24,
(0xE2), 0x3F,
(0x35), 0x00,
(0x36), 0x00,
(0x3A), /*16/18 bit*/ 0x55, /*66->18 bit, 55->16bit.*/
(0x2A), 0x00, 0x00, 0x00, 0xEF,
(0x2B), 0x00, 0x00, 0x01, 0x3F,
(0x2C),
(0x11),
TFTLCD_DELAY8, 40 ,
(0x29),
(0x2C),
/* 3. LGD 2.6” Gamma 2.5 Initial Code(2/2)*/
(0xB0), 0x3F, 0x3F,
TFTLCD_DELAY8, 5,
(0xB3), 0x02, 0x00, 0x00, 0x00, 0x00,
(0xB4), 0x00,
(0xC0), 0x33, 0x4F, 0x00, 0x10, 0xA2, 0x00, 0x01, 0x00,
(0xC1), 0x01, 0x02, 0x24, 0x04, 0x04,
TFTLCD_DELAY8, 25,
(0xC4), 0x11, 0x01, 0x00, 0x00, 0x00,
/*Gamma setting start*/
(0xC8), /*Gamma*/ 0x07, 0x09, 0x0A, 0x11, 0x17, 0x0A, 0x08, 0x04, 0x07, 0x03, 0x00, 0x03, 0x07, 0x04, 0x08, 0x0A, 0x17, 0x11, 0x0A, 0x09, 0x07, 0x00,
(0xC9), /*Gamma*/ 0x07, 0x09, 0x0A, 0x11, 0x17, 0x0A, 0x08, 0x04, 0x07, 0x03, 0x00, 0x03, 0x07, 0x04, 0x08, 0x0A, 0x17, 0x11, 0x0A, 0x09, 0x07, 0x00,
(0xCA), /*Gamma*/ 0x07, 0x09, 0x0A, 0x11, 0x17, 0x0A, 0x08, 0x04, 0x07, 0x03, 0x00, 0x03, 0x07, 0x04, 0x08, 0x0A, 0x17, 0x11, 0x0A, 0x09, 0x07, 0x00,
/* 4. TIAMMA 2.4” Gamma 2.2 Initial Code(1/2)*/
/*Power setting start*/
(0xD0), 0x33, 0x53, 0x85, 0x3A, 0x30, 0x00,
(0xD1), 0x5F, /*VCM 1B~7F*/ 0x78, /*VDV 25~7F*/ 0x10,
(0xD2), 0x03, 0x24,
(0xE2), 0x3F,
/*Power setting End*/
(0x35), 0x00,
(0x36), 0x00,
(0x3A), 0x66, /*66->18 bit, 55->16bit.*/
(0x2A), 0x00, 0x00, 0x00, 0xEF,
(0x2B), 0x00, 0x00, 0x01, 0x3F,
(0x2C),
(0x11),
TFTLCD_DELAY8, 40,
(0x29),
(0x2C),
/* 4. TIAMMA 2.4” Gamma 2.2 Initial Code(2/2)*/
(0xB0), 0x3F, 0x3F,
TFTLCD_DELAY8, 5,
(0xB3), 0x02, 0x00, 0x00, 0x00, 0x00,
(0xB4), 0x00,
(0xC0), 0x33, 0x4F, 0x00, 0x10, 0xA2, 0x00, 0x01, 0x00,
(0xC1), 0x01, 0x02, 0x24, 0x04, 0x04,
TFTLCD_DELAY8, 25,
(0xC4), 0x11, 0x01, 0x00, 0x00, 0x00,
/*Gamma setting start*/
(0xC8), /*Gamma*/ 0x07, 0x09, 0x0A, 0x0C, 0x18, 0x0D, 0x05, 0x04, 0x07, 0x03, 0x00, 0x03, 0x07, 0x04, 0x05, 0x0D, 0x18, 0x0C, 0x0A, 0x09, 0x07, 0x00,
(0xC9), /*Gamma*/ 0x07, 0x09, 0x0A, 0x0C, 0x18, 0x0D, 0x05, 0x04, 0x07, 0x03, 0x00, 0x03, 0x07, 0x04, 0x05, 0x0D, 0x18, 0x0C, 0x0A, 0x09, 0x07, 0x00,
(0xCA), /*Gamma*/ 0x07, 0x09, 0x0A, 0x0C, 0x18, 0x0D, 0x05, 0x04, 0x07, 0x03, 0x00, 0x03, 0x07, 0x04, 0x05, 0x0D, 0x18, 0x0C, 0x0A, 0x09, 0x07, 0x00,
/* 4. TIAMMA 2.4” Gamma 2.5 Initial Code(1/2)*/
/*Power setting start*/
(0xD0), 0x33, 0x53, 0x85, 0x3D, 0x30, 0x00,
(0xD1), 0x5F, /*VCM 1B~7F*/ 0x78, /*VDV 25~7F*/ 0x10,
(0xD2), 0x03, 0x24,
(0xE2), 0x3F,
/*Power setting End*/
(0x35), 0x00,
(0x36), 0x00,
(0x3A), 0x66, /*66->18 bit, 55->16bit.*/
(0x2A), 0x00, 0x00, 0x00, 0xEF,
(0x2B), 0x00, 0x00, 0x01, 0x3F,
(0x2C),
(0x11),
TFTLCD_DELAY8, 40,
(0x29),
(0x2C),
/* 4. TIAMMA 2.4” Gamma 2.5 Initial Code(2/2)*/
(0xB0), 0x3F, 0x3F,
TFTLCD_DELAY8, 5,
(0xB3), 0x02, 0x00, 0x00, 0x00, 0x00,
(0xB4), 0x00,
(0xC0), 0x33, 0x4F, 0x00, 0x10, 0xA2, 0x00, 0x01, 0x00,
(0xC1), 0x01, 0x02, 0x1A, /*86Hz*/ 0x04, 0x04,
TFTLCD_DELAY8, 25,
(0xC4), 0x11, 0x01, 0x00, 0x00, 0x00,
/*Gamma setting start*/
(0xC8), /*GAMMA*/ 0x05, /*V0*/ 0x00, /*V1*/ 0x07, /*V4*/ 0x14, /*V8*/ 0x20, /*V20*/ 0x02, /*V43*/ 0x09, /*V55*/ 0x00, /*V59*/ 0x01, /*V62*/ 0x01, /*V63*/ 0x00, 0x01, /*V63*/ 0x01, /*V62*/ 0x00, /*V59*/ 0x09, /*V55*/ 0x02, /*V43*/ 0x20, /*V20*/ 0x14, /*V8*/ 0x07, /*V4*/ 0x00, /*V1*/ 0x05, /*V0*/ 0x00,
(0xC9), /*GAMMA*/ 0x05, /*V0*/ 0x00, /*V1*/ 0x07, /*V4*/ 0x14, /*V8*/ 0x20, /*V20*/ 0x02, /*V43*/ 0x09, /*V55*/ 0x00, /*V59*/ 0x01, /*V62*/ 0x01, /*V63*/ 0x00, 0x01, /*V63*/ 0x01, /*V62*/ 0x00, /*V59*/ 0x09, /*V55*/ 0x02, /*V43*/ 0x20, /*V20*/ 0x14, /*V8*/ 0x07, /*V4*/ 0x00, /*V1*/ 0x05, /*V0*/ 0x00,
(0xCA), /*GAMMA*/ 0x05, /*V0*/ 0x00, /*V1*/ 0x07, /*V4*/ 0x14, /*V8*/ 0x20, /*V20*/ 0x02, /*V43*/ 0x09, /*V55*/ 0x00, /*V59*/ 0x01, /*V62*/ 0x01, /*V63*/ 0x00, 0x01, /*V63*/ 0x01, /*V62*/ 0x00, /*V59*/ 0x09, /*V55*/ 0x02, /*V43*/ 0x20, /*V20*/ 0x14, /*V8*/ 0x07, /*V4*/ 0x00, /*V1*/ 0x05, /*V0*/ 0x00,
/* 5. BOE 2.0” Gamma 2.2 Initial Code(1/2)*/
/*Power setting start*/
(0xD0), 0x33, 0x53, 0x85, 0x3A, 0x37, 0x00,
(0xD1), 0x41, /*VCM 1B~7F*/ 0x78, /*VDV 25~7F*/ 0x10,
(0xD2), 0x03, 0x22,
(0xE2), 0x3F,
/*Power setting End*/
(0x35), 0x00,
(0x36), 0x00,
(0x3A), 0x66, /*66->18 bit, 55->16bit.*/
(0x2A), 0x00, 0x00, 0x00, 0xEF,
(0x2B), 0x00, 0x00, 0x01, 0x3F,
(0x2C),
(0x11),
TFTLCD_DELAY8, 40,
(0x29),
(0x2C),
/* 5. BOE 2.0” Gamma 2.2 Initial Code(2/2)*/
(0xB0), 0x3F, 0x3F,
TFTLCD_DELAY8, 5,
(0xB3), 0x02, 0x00, 0x00, 0x00, 0x00,
(0xB4), 0x00,
(0xC0), 0x33, 0x4F, 0x00, 0x10, 0xA2, 0x00, 0x01, 0x00,
(0xC1), 0x01, 0x02, 0x1A, /*86Hz*/ 0x04, 0x04,
TFTLCD_DELAY8, 25,
(0xC4), 0x11, 0x01, 0x00, 0x00, 0x00,
/*Gamma setting start*/
(0xC8), /*GAMMA*/ 0x05, /*V0*/ 0x00, /*V1*/ 0x05, /*V4*/ 0x11, /*V8*/ 0x31, /*V20*/ 0x01, /*V43*/ 0x0B, /*V55*/ 0x00, /*V59*/ 0x01, /*V62*/ 0x05, /*V63*/ 0x00, 0x05, /*V63*/ 0x01, /*V62*/ 0x00, /*V59*/ 0x0B, /*V55*/ 0x01, /*V43*/ 0x31, /*V20*/ 0x11, /*V8*/ 0x05, /*V4*/ 0x00, /*V1*/ 0x05, /*V0*/ 0x00,
(0xC9), /*GAMMA*/ 0x05, /*V0*/ 0x00, /*V1*/ 0x05, /*V4*/ 0x11, /*V8*/ 0x31, /*V20*/ 0x01, /*V43*/ 0x0B, /*V55*/ 0x00, /*V59*/ 0x01, /*V62*/ 0x05, /*V63*/ 0x00, 0x05, /*V63*/ 0x01, /*V62*/ 0x00, /*V59*/ 0x0B, /*V55*/ 0x01, /*V43*/ 0x31, /*V20*/ 0x11, /*V8*/ 0x05, /*V4*/ 0x00, /*V1*/ 0x05, /*V0*/ 0x00,
(0xCA), /*GAMMA*/ 0x05, /*V0*/ 0x00, /*V1*/ 0x05, /*V4*/ 0x11, /*V8*/ 0x31, /*V20*/ 0x01, /*V43*/ 0x0B, /*V55*/ 0x00, /*V59*/ 0x01, /*V62*/ 0x05, /*V63*/ 0x00, 0x05, /*V63*/ 0x01, /*V62*/ 0x00, /*V59*/ 0x0B, /*V55*/ 0x01, /*V43*/ 0x31, /*V20*/ 0x11, /*V8*/ 0x05, /*V4*/ 0x00, /*V1*/ 0x05, /*V0*/ 0x00,
/* 5. BOE 2.0” Gamma 2.5 Initial Code(1/2)*/
/*Power setting start*/
(0xD0), 0x33, 0x53, 0x85, 0x3A, 0x37, 0x00,
(0xD1), 0x5B, /*VCM 1B~7F*/ 0x78, /*VDV 25~7F*/ 0x10,
(0xD2), 0x03, 0x22,
(0xE2), 0x3F,
/*Power setting End*/
(0x35), 0x00,
(0x36), 0x00,
(0x3A), 0x66, /*66->18 bit, 55->16bit.*/
(0x2A), 0x00, 0x00, 0x00, 0xEF,
(0x2B), 0x00, 0x00, 0x01, 0x3F,
(0x2C),
(0x11),
TFTLCD_DELAY8, 40,
(0x29),
(0x2C),
/* 5. BOE 2.0” Gamma 2.5 Initial Code(2/2)*/
libraries/MCUFRIEND_kbv/keywords.txt
+67
View File
@@ -0,0 +1,67 @@
#######################################
# Syntax Coloring Map For Mcufriend_kbv
#######################################
#######################################
# Datatypes (KEYWORD1)
#######################################
MCUFRIEND_kbv KEYWORD1
#UTFTGLUE KEYWORD1
#######################################
# Methods and Functions (KEYWORD2)
#######################################
#InitLCD KEYWORD2
#LCD_Write_DATA KEYWORD2
WriteCmdData KEYWORD2
begin KEYWORD2
#clrScr KEYWORD2
color565 KEYWORD2
#dispBitmap KEYWORD2
#drawBitmap KEYWORD2
drawCircle KEYWORD2
drawFastHLine KEYWORD2
drawFastVLine KEYWORD2
drawLine KEYWORD2
drawPixel KEYWORD2
drawRect KEYWORD2
drawRoundRect KEYWORD2
fillCircle KEYWORD2
fillRect KEYWORD2
fillRoundRect KEYWORD2
#fillScr KEYWORD2
fillScreen KEYWORD2
#getDisplayXSize KEYWORD2
#getDisplayYSize KEYWORD2
height KEYWORD2
invertDisplay KEYWORD2
#lcdOff KEYWORD2
#lcdOn KEYWORD2
#ltoa KEYWORD2
#print KEYWORD2
#printNumF KEYWORD2
#printNumI KEYWORD2
#println KEYWORD2
pushColors KEYWORD2
readGRAM KEYWORD2
readID KEYWORD2
readPixel KEYWORD2
readReg KEYWORD2
readReg32 KEYWORD2
reset KEYWORD2
setAddrWindow KEYWORD2
#setBackColor KEYWORD2
#setColor KEYWORD2
#setContrast KEYWORD2
setCursor KEYWORD2
#setFont KEYWORD2
setRotation KEYWORD2
#setrgb KEYWORD2
setTextColor KEYWORD2
setTextSize KEYWORD2
#settextcursor KEYWORD2
vertScroll KEYWORD2
width KEYWORD2
#write_data_block KEYWORD2
libraries/MCUFRIEND_kbv/library.properties
+9
View File
@@ -0,0 +1,9 @@
name=MCUFRIEND_kbv
version=3.0.0-Release
author=David Prentice
maintainer=David Prentice
sentence=TFT Library for 2.4, 2.8, 3.5, 3.6, 3.95 inch mcufriend UNO Shields
paragraph=TFT Library for 2.4, 2.8, 3.5, 3.6, 3.95 inch mcufriend UNO Shields. Must have /RD pin to be readable.
category=Display
url=https://github.com/prenticedavid/MCUFRIEND_kbv
architectures=*
libraries/MCUFRIEND_kbv/license.txt
+85
View File
@@ -0,0 +1,85 @@
/*
* MCUFRIEND_kbv class inherits from Adafruit_GFX class and the Arduino Print class.
* Any use of MCUFRIEND_kbv class and examples is dependent on Adafruit and Arduino licenses
* The license texts are in the accompanying license.txt file
*/
ADAFRUIT: Adafruit_GFX library
Software License Agreement (BSD License)
Copyright (c) 2012 Adafruit Industries. All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
- Redistributions of source code must retain the above copyright notice,
this list of conditions and the following disclaimer.
- Redistributions in binary form must reproduce the above copyright notice,
this list of conditions and the following disclaimer in the documentation
and/or other materials provided with the distribution.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
POSSIBILITY OF SUCH DAMAGE.
ARDUINO: Print class
/*
Copyright (c) 2014 Arduino. 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
*/
vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvStartvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv
Software License Agreement (FreeBSD License)
Copyright (c) 2018 David Prentice (https://github.com/prenticedavid/MCUFRIEND_kbv/)
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
1. Redistributions of source code must retain the above copyright notice, this
list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright notice,
this list of conditions and the following disclaimer in the documentation
and/or other materials provided with the distribution.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
The views and conclusions contained in the software and documentation are those
of the authors and should not be interpreted as representing official policies,
either expressed or implied, of the FreeBSD Project.
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^End^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
libraries/MCUFRIEND_kbv/utility/mcufriend_keil.h
+122
View File
@@ -0,0 +1,122 @@
#ifndef MCUFRIEND_KEIL_H_
#define MCUFRIEND_KEIL_H_
#if defined(USE_SERIAL)
#include "mcufriend_keil_spi.h"
#else
#include "pin_shield_1.h" //shield pin macros e.g. A2_PORT, PIN_OUTPUT()
#include "pin_shield_8.h" //macros for write_8(), read_8(), setWriteDir(), ...
// control pins as used in MCUFRIEND shields
#define RD_PORT A0_PORT
#define RD_PIN A0_PIN
#define WR_PORT A1_PORT
#define WR_PIN A1_PIN
#define CD_PORT A2_PORT
#define CD_PIN A2_PIN
#define CS_PORT A3_PORT
#define CS_PIN A3_PIN
#define RESET_PORT A4_PORT
#define RESET_PIN A4_PIN
// general purpose pin macros
#define RD_ACTIVE PIN_LOW(RD_PORT, RD_PIN)
#define RD_IDLE PIN_HIGH(RD_PORT, RD_PIN)
#define RD_OUTPUT PIN_OUTPUT(RD_PORT, RD_PIN)
#define WR_ACTIVE PIN_LOW(WR_PORT, WR_PIN)
#define WR_IDLE PIN_HIGH(WR_PORT, WR_PIN)
#define WR_OUTPUT PIN_OUTPUT(WR_PORT, WR_PIN)
#define CD_COMMAND PIN_LOW(CD_PORT, CD_PIN)
#define CD_DATA PIN_HIGH(CD_PORT, CD_PIN)
#define CD_OUTPUT PIN_OUTPUT(CD_PORT, CD_PIN)
#define CS_ACTIVE PIN_LOW(CS_PORT, CS_PIN)
#define CS_IDLE PIN_HIGH(CS_PORT, CS_PIN)
#define CS_OUTPUT PIN_OUTPUT(CS_PORT, CS_PIN)
#define RESET_ACTIVE PIN_LOW(RESET_PORT, RESET_PIN)
#define RESET_IDLE PIN_HIGH(RESET_PORT, RESET_PIN)
#define RESET_OUTPUT PIN_OUTPUT(RESET_PORT, RESET_PIN)
#define WR_ACTIVE2 {WR_ACTIVE; WR_ACTIVE;}
#define WR_ACTIVE4 {WR_ACTIVE2; WR_ACTIVE2;}
#define WR_ACTIVE8 {WR_ACTIVE4; WR_ACTIVE4;}
#define RD_ACTIVE2 {RD_ACTIVE; RD_ACTIVE;}
#define RD_ACTIVE4 {RD_ACTIVE2; RD_ACTIVE2;}
#define RD_ACTIVE8 {RD_ACTIVE4; RD_ACTIVE4;}
#define RD_ACTIVE16 {RD_ACTIVE8; RD_ACTIVE8;}
#define WR_IDLE2 {WR_IDLE; WR_IDLE;}
#define WR_IDLE4 {WR_IDLE2; WR_IDLE2;}
#define RD_IDLE2 {RD_IDLE; RD_IDLE;}
#define RD_IDLE4 {RD_IDLE2; RD_IDLE2;}
// General macros. IOCLR registers are 1 cycle when optimised.
#define WR_STROBE { WR_ACTIVE; WR_IDLE; } //PWLW=TWRL=50ns
#define RD_STROBE RD_IDLE, RD_ACTIVE, RD_ACTIVE, RD_ACTIVE //PWLR=TRDL=150ns
#if defined(__ARM_ARCH_7M__) || defined(__ARM_ARCH_7EM__) || __TARGET_ARCH_THUMB == 4 // -O2: F411@100MHz = 1.44s
//#define WRITE_DELAY { WR_ACTIVE; WR_ACTIVE; WR_ACTIVE; WR_ACTIVE; }
//#define READ_DELAY { RD_ACTIVE; RD_ACTIVE; RD_ACTIVE; RD_ACTIVE; RD_ACTIVE; RD_ACTIVE; RD_ACTIVE; }
#if 0
#elif defined(MK20D5)
#warning 50Hz
#define WRITE_DELAY { } //50MHz
#define READ_DELAY { RD_ACTIVE; }
#elif defined(STM32F103xB)
#warning 72MHz
#define WRITE_DELAY { } //72MHz
#define READ_DELAY { RD_ACTIVE; }
#elif defined(STM32L476xx)
#warning 80MHz
#define WRITE_DELAY { WR_ACTIVE2; } //80MHz
#define READ_DELAY { RD_ACTIVE4; }
#elif defined(__SAM3X8E__)
#warning 84MHz
#define WRITE_DELAY { WR_ACTIVE; } //84MHz
#define READ_DELAY { RD_ACTIVE; }
#elif defined(STM32F401xE)
#warning 84MHz
#define WRITE_DELAY { WR_ACTIVE2; } //84MHz
#define READ_DELAY { RD_ACTIVE8; }
#elif defined(STM32F411xE)
#define WRITE_DELAY { WR_ACTIVE2; WR_ACTIVE; } //100MHz
#define READ_DELAY { RD_ACTIVE4; RD_ACTIVE2; }
#elif defined(SAM4S_XPRO)
#warning 120MHz
#define WRITE_DELAY { WR_ACTIVE4; } //120MHz
#define READ_DELAY { RD_ACTIVE8; }
#elif defined(STM32F446xx)
#warning 180MHz
#define WRITE_DELAY { WR_ACTIVE8; } //180MHz
#define IDLE_DELAY { WR_IDLE2;WR_IDLE; }
#define READ_DELAY { RD_ACTIVE16;}
#elif defined(STM32F767xx)
#warning 216MHz
#define WRITE_DELAY { WR_ACTIVE8; WR_ACTIVE8; } //216MHz
#define IDLE_DELAY { WR_IDLE4;WR_IDLE4; }
#define READ_DELAY { RD_ACTIVE16;RD_ACTIVE16;RD_ACTIVE16;}
#elif defined(STM32H743xx) //STM32H743 GPIO needs testing
#define WRITE_DELAY { WR_ACTIVE8;WR_ACTIVE2; } //F_CPU=400MHz
#define IDLE_DELAY { WR_IDLE2;WR_IDLE; }
#define READ_DELAY { RD_ACTIVE16;RD_ACTIVE16;RD_ACTIVE4;}
#else
#error check specific STM32
#endif
#elif defined(__ARM_ARCH_6M__) // -O2: F072@48MHz = 5.03s
#define WRITE_DELAY { }
#define READ_DELAY { }
#endif
#ifndef IDLE_DELAY
#define IDLE_DELAY { WR_IDLE; }
#endif
#define write8(x) { write_8(x); WRITE_DELAY; WR_STROBE; IDLE_DELAY; }
#define write16(x) { uint8_t h = (x)>>8, l = x; write8(h); write8(l); }
#define READ_8(dst) { RD_STROBE; READ_DELAY; dst = read_8(); RD_IDLE2; RD_IDLE; } // read 250ns after RD_ACTIVE goes low
#define READ_16(dst) { uint8_t hi; READ_8(hi); READ_8(dst); dst |= (hi << 8); }
#define CTL_INIT() { RD_OUTPUT; WR_OUTPUT; CD_OUTPUT; CS_OUTPUT; RESET_OUTPUT; }
#define WriteCmd(x) { CD_COMMAND; write16(x); CD_DATA; }
#define WriteData(x) { write16(x); }
#endif //!USE_SERIAL
#endif //MCUFRIEND_KEIL_H_
libraries/MCUFRIEND_kbv/utility/mcufriend_mbed.h
+100
View File
@@ -0,0 +1,100 @@
#ifndef MCUFRIEND_MBED_H_
#define MCUFRIEND_MBED_H_
#include <mbed.h>
#if defined(USE_SERIAL)
#include "mcufriend_keil_spi.h"
#else
BusOut digitalL(D0, D1, D2, D3, D4, D5, D6, D7);
BusOut digitalH(D8, D9, D10, D11, D12, D13, NC, NC);
BusOut analog(A0, A1, A2, A3, A4, A5, NC, NC);
#include "pin_shield_1.h" //shield pin macros e.g. A2_PORT, PIN_OUTPUT()
#include "pin_shield_8.h" //macros for write_8(), read_8(), setWriteDir(), ...
// control pins as used in MCUFRIEND shields
#define RD_PORT A0_PORT
#define RD_PIN A0_PIN
#define WR_PORT A1_PORT
#define WR_PIN A1_PIN
#define CD_PORT A2_PORT
#define CD_PIN A2_PIN
#define CS_PORT A3_PORT
#define CS_PIN A3_PIN
#define RESET_PORT A4_PORT
#define RESET_PIN A4_PIN
// general purpose pin macros
#define RD_ACTIVE PIN_LOW(RD_PORT, RD_PIN)
#define RD_IDLE PIN_HIGH(RD_PORT, RD_PIN)
#define RD_OUTPUT PIN_OUTPUT(RD_PORT, RD_PIN)
#define WR_ACTIVE PIN_LOW(WR_PORT, WR_PIN)
#define WR_IDLE PIN_HIGH(WR_PORT, WR_PIN)
#define WR_OUTPUT PIN_OUTPUT(WR_PORT, WR_PIN)
#define CD_COMMAND PIN_LOW(CD_PORT, CD_PIN)
#define CD_DATA PIN_HIGH(CD_PORT, CD_PIN)
#define CD_OUTPUT PIN_OUTPUT(CD_PORT, CD_PIN)
#define CS_ACTIVE PIN_LOW(CS_PORT, CS_PIN)
#define CS_IDLE PIN_HIGH(CS_PORT, CS_PIN)
#define CS_OUTPUT PIN_OUTPUT(CS_PORT, CS_PIN)
#define RESET_ACTIVE PIN_LOW(RESET_PORT, RESET_PIN)
#define RESET_IDLE PIN_HIGH(RESET_PORT, RESET_PIN)
#define RESET_OUTPUT PIN_OUTPUT(RESET_PORT, RESET_PIN)
#define WR_ACTIVE2 {WR_ACTIVE; WR_ACTIVE;}
#define WR_ACTIVE4 {WR_ACTIVE2; WR_ACTIVE2;}
#define WR_ACTIVE8 {WR_ACTIVE4; WR_ACTIVE4;}
#define RD_ACTIVE2 {RD_ACTIVE; RD_ACTIVE;}
#define RD_ACTIVE4 {RD_ACTIVE2; RD_ACTIVE2;}
#define RD_ACTIVE8 {RD_ACTIVE4; RD_ACTIVE4;}
#define RD_ACTIVE16 {RD_ACTIVE8; RD_ACTIVE8;}
#define WR_IDLE2 {WR_IDLE; WR_IDLE;}
#define WR_IDLE4 {WR_IDLE2; WR_IDLE2;}
#define RD_IDLE2 {RD_IDLE; RD_IDLE;}
#define RD_IDLE4 {RD_IDLE2; RD_IDLE2;}
#if defined(__MK20DX128__) || defined(___MK20DX256__) // Teensy3.0 || 3.2 96MHz
#define WRITE_DELAY { WR_ACTIVE2; }
#define READ_DELAY { RD_ACTIVE4; RD_ACTIVE; }
#elif defined(__MK64FX512__) || defined(TARGET_M4) // Teensy3.5 120MHz thanks to PeteJohno
#define WRITE_DELAY { WR_ACTIVE4; }
#define READ_DELAY { RD_ACTIVE8; }
#elif defined(__MK66FX1M0__) || defined(TARGET_M4) // Teensy3.6 180MHz untested. delays can possibly be reduced.
#define WRITE_DELAY { WR_ACTIVE8; }
#define READ_DELAY { RD_ACTIVE8; RD_ACTIVE8; }
#elif defined(TARGET_M7) // Nucleo-F767 216MHz untested. delays can possibly be reduced.
#define WRITE_DELAY { WR_ACTIVE8; WR_ACTIVE2; }
#define IDLE_DELAY { WR_IDLE2;WR_IDLE; }
#define READ_DELAY { RD_ACTIVE16; RD_ACTIVE16; RD_ACTIVE4; }
#define READ_IDLE { RD_IDLE2;RD_IDLE; }
#else
//#error unspecified delays
//#define WRITE_DELAY { WR_ACTIVE2; }
//#define READ_DELAY { RD_ACTIVE4; RD_ACTIVE; }
#define WRITE_DELAY
#define READ_DELAY
#endif
#if !defined(IDLE_DELAY)
#define IDLE_DELAY WR_IDLE
#endif
#if !defined(READ_IDLE)
#define READ_IDLE RD_IDLE
#endif
// General macros. IOCLR registers are 1 cycle when optimised.
#define WR_STROBE { WR_ACTIVE; WR_IDLE; } //PWLW=TWRL=50ns
#define RD_STROBE RD_IDLE, RD_ACTIVE, RD_ACTIVE, RD_ACTIVE //PWLR=TRDL=150ns
#define write8(d) { write_8(d); WRITE_DELAY; WR_STROBE; IDLE_DELAY; } // STROBEs are defined later
#define write16(x) { uint8_t h = (x)>>8, l = x; write8(h); write8(l); }
#define READ_8(dst) { RD_STROBE; READ_DELAY; dst = read_8(); READ_IDLE; } // read 250ns after RD_ACTIVE goes low
#define READ_16(dst) { uint8_t hi; READ_8(hi); READ_8(dst); dst |= (hi << 8); }
#define CTL_INIT() { RD_OUTPUT; WR_OUTPUT; CD_OUTPUT; CS_OUTPUT; RESET_OUTPUT; }
#define WriteCmd(x) { CD_COMMAND; write16(x); CD_DATA; }
#define WriteData(x) { write16(x); }
#endif //!USE_SERIAL
#endif //MCUFRIEND_KEIL_H_
libraries/MCUFRIEND_kbv/utility/mcufriend_serial.h
+243
View File
@@ -0,0 +1,243 @@
#if ARDUINO >= 165
#include <SPI.h>
#endif
#if 0
#elif defined(__AVR_ATmega328P__)
#define SPI_INIT() { DDRB |= (1<<5)|(1<<3)|(1<<2); SPCR = (1<<SPE)|(1<<MSTR); SPSR = (1<<SPI2X); SPSR; SPDR; }
static inline uint8_t spi_xfer(uint8_t c)
{
SPDR = c;
while ((SPSR & (1<<SPIF)) == 0) ;
return SPDR;
}
extern uint8_t running;
static inline void write8(uint8_t x) {
if (running) {
while ((SPSR & 0x80) == 0);
SPDR;
}
SPDR = x;
running = 1;
}
static inline uint8_t read8(void) {
if (running) while ((SPSR & 0x80) == 0);
running = 0;
return SPDR;
}
static inline uint8_t xchg8(uint8_t x) { write8(x); return read8(); }
static inline void flush(void) {
if (running) {
while ((SPSR & 0x80) == 0);
}
running = 0;
SPDR;
}
#if defined(SUPPORT_8347D)
#warning using HX8347D hardware
#define CD_PORT PORTD
#define CD_PIN PD7
#define CS_PORT PORTB
#define CS_PIN PB2
#define RESET_PORT PORTB
#define RESET_PIN PB1
#define SD_PIN PD5
#define XPT_PIN PD4
#define RD_IDLE
#define WR_IDLE
#else
#warning using regular SPI hardware
#define CD_PORT PORTB
#define CD_PIN 1
#define CS_PORT PORTB
#define CS_PIN 2
#define RESET_PORT PORTB
#define RESET_PIN 0
#define RD_IDLE
#define WR_IDLE
#endif
#define setWriteDir() { }
#define setReadDir() { }
//#define write8(x) spi_xfer(x)
#define write16(x) { uint8_t h = (x)>>8, l = x; write8(h); write8(l); }
#define READ_8(dst) { dst = xchg8(0); }
#define READ_16(dst) { dst = xchg8(0); dst = (dst << 8) | xchg8(0); }
#define PIN_LOW(p, b) (p) &= ~(1<<(b))
#define PIN_HIGH(p, b) (p) |= (1<<(b))
#define PIN_OUTPUT(p, b) *(&p-1) |= (1<<(b))
#elif defined(__SAMD21G18A__)
#define SPI_INIT() { SPI.begin(); SPI.setDataMode(SPI_MODE0); SPI.setClockDivider(6); }
#define CD_PORT PORT->Group[0]
#define CD_PIN 7
#define CS_PORT PORT->Group[0]
#define CS_PIN 18
#define RESET_PORT PORT->Group[0]
#define RESET_PIN 6
#define RD_IDLE
#define WR_IDLE
uint8_t running;
static inline void write8(uint8_t c)
{
running = 1;
while( SERCOM1->SPI.INTFLAG.bit.DRE == 0) ;
SERCOM1->SPI.DATA.bit.DATA = c; // Writing data into Data register
}
static inline void flush(void)
{
if (running) while( SERCOM1->SPI.INTFLAG.bit.TXC == 0) ;
running = 0;
}
static inline uint8_t xchg8(uint8_t c)
{
// flush();
while( SERCOM1->SPI.INTFLAG.bit.RXC != 0) SERCOM1->SPI.DATA.bit.DATA; //eat up
while( SERCOM1->SPI.INTFLAG.bit.DRE == 0) ;
SERCOM1->SPI.DATA.bit.DATA = c; // Writing data into Data register
while( SERCOM1->SPI.INTFLAG.bit.RXC == 0) ;
return SERCOM1->SPI.DATA.bit.DATA;
}
#define setWriteDir() { }
#define setReadDir() { }
//#define flush()
//#define write8(x) xchg8(x)
//#define xchg8(x) SPI.transfer(x)
#define write16(x) { uint8_t h = (x)>>8, l = x; write8(h); write8(l); }
#define READ_8(dst) { dst = xchg8(0); }
#define READ_16(dst) { dst = xchg8(0); dst = (dst << 8) | xchg8(0); }
// Shield Control macros.
#define PIN_LOW(port, pin) (port).OUTCLR.reg = (1<<(pin))
#define PIN_HIGH(port, pin) (port).OUTSET.reg = (1<<(pin))
#define PIN_OUTPUT(port, pin) (port).DIR.reg |= (1<<(pin))
#elif defined(__AVR_ATxmega128A1__) //3.49s @ 32MHz -O2
#define CD_PORT VPORT2
#define CD_PIN 1
#define CS_PORT VPORT3
#define CS_PIN 4
#define RESET_PORT VPORT2
#define RESET_PIN 0
#define SPCRVAL (USART_CLK2X_bm | USART_RXEN_bm | USART_TXEN_bm)
#define SETDDR {VPORT3.DIR |= (1<<4)|(1<<5)|(1<<7); VPORT2.DIR |= 0x03; }
#define SPI_INIT() { PORTCFG.VPCTRLB=PORTCFG_VP3MAP_PORTF_gc | PORTCFG_VP2MAP_PORTC_gc; CS_IDLE; RESET_IDLE; SETDDR; spi_init(); }
void spi_init(void)
{
SPIF.CTRL=SPI_ENABLE_bm | SPI_MODE_3_gc | (1<<SPI_MASTER_bp) | (1<<SPI_CLK2X_bp);
}
#define write8(x) {\
SPIF.DATA=x;\
while ((SPIF.STATUS & SPI_IF_bm)==0);\
SPIF.DATA;\
}
#define flush() {\
}
#define PIN_LOW(p, b) (p).OUT &= ~(1<<(b))
#define PIN_HIGH(p, b) (p).OUT |= (1<<(b))
#define PIN_OUTPUT(p, b) (p).DIR |= (1<<(b))
#elif defined(__AVR_ATxmega32A4U__) //3.49s @ 32MHz -O2.
// 100ns/150ns for ILI9341 W/R cycle. 100ns/200ns for ILI920. 20ns/150ns HX8347
// Xmega @ 60MHz i.e. 30MHz SCK works with 9341.
#warning Using ATxmega32A4U USART_MSPI
#define CD_PORT VPORT2
#define CD_PIN 1
#define CS_PORT VPORT3
#define CS_PIN 0
#define RESET_PORT VPORT2
#define RESET_PIN 0
#define SD_PORT PORTC
#define SD_PIN 4
#define SPCRVAL (USART_CLK2X_bm | USART_RXEN_bm | USART_TXEN_bm)
#define SETDDR {PORTCFG.VPCTRLB=PORTCFG_VP13MAP_PORTD_gc | PORTCFG_VP02MAP_PORTC_gc; VPORT3.DIR |= (1<<0)|(1<<1)|(1<<3); VPORT2.DIR |= 0x03; PIN_HIGH(SD_PORT, SD_PIN); SD_PORT.DIR |= (1<<SD_PIN); }
#define SPI_INIT() { CS_IDLE; RESET_IDLE; SETDDR; spi_init(); }
static inline void spi_init(void)
{
USARTD0.CTRLB = SPCRVAL;
USARTD0.CTRLC = USART_CMODE_MSPI_gc | 0x00 | 0x00; //mode #0
// PORTD.PIN1CTRL |= PORT_INVEN_bm; //CPOL
USARTD0.BAUDCTRLA = 0x00; //F_CPU/2
USARTD0.BAUDCTRLB = ((0x00 << USART_BSCALE_gp) & USART_BSCALE_gm) | 0x00;
USARTD0.DATA;
}
extern uint8_t running;
#define write8(x) {\
while ((USARTD0.STATUS & USART_DREIF_bm) == 0) ;\
asm("cli");\
USARTD0.DATA = x;\
USARTD0.STATUS = USART_TXCIF_bm;\
asm("sei");\
running = 1;\
}
static inline uint8_t read8(void) {
if (running) while ((USARTD0.STATUS & USART_RXCIF_bm) == 0) ;
return USARTD0.DATA;
}
#define flush() {\
if (running) while ((USARTD0.STATUS & USART_TXCIF_bm) == 0) ;\
while ((USARTD0.STATUS & USART_RXCIF_bm) != 0) USARTD0.DATA;\
running = 0;\
}
static inline uint8_t xchg8(uint8_t x) {
USARTD0.DATA = x;
while ((USARTD0.STATUS & USART_RXCIF_bm) == 0) ;
return USARTD0.DATA;
}
/*
#define write8(x) {\
while ((USARTD0.STATUS & USART_DREIF_bm) == 0) ;\
USARTD0.DATA = x;\
while ((USARTD0.STATUS & USART_RXCIF_bm) == 0) ;\
USARTD0.DATA;\
}
#define flush()
*/
#define RD_IDLE
#define WR_IDLE
//#define SPI_INIT() spi_init()
#define setWriteDir() { }
#define setReadDir() { }
//#define write8(x) spi_xfer(x)
#define write16(x) { uint8_t h = (x)>>8, l = x; write8(h); write8(l); }
#define READ_8(dst) { dst = xchg8(0); }
#define READ_16(dst) { dst = xchg8(0); dst = (dst << 8) | xchg8(0); }
#define PIN_LOW(p, b) (p).OUT &= ~(1<<(b))
#define PIN_HIGH(p, b) (p).OUT |= (1<<(b))
#define PIN_OUTPUT(p, b) (p).DIR |= (1<<(b))
#endif
#define CD_COMMAND {flush(); PIN_LOW(CD_PORT, CD_PIN); }
#define CD_DATA {flush(); PIN_HIGH(CD_PORT, CD_PIN); }
#define CD_OUTPUT PIN_OUTPUT(CD_PORT, CD_PIN)
#define CS_ACTIVE PIN_LOW(CS_PORT, CS_PIN)
#define CS_IDLE {flush(); PIN_HIGH(CS_PORT, CS_PIN); }
#define CS_OUTPUT PIN_OUTPUT(CS_PORT, CS_PIN)
#define RESET_ACTIVE PIN_LOW(RESET_PORT, RESET_PIN)
#define RESET_IDLE PIN_HIGH(RESET_PORT, RESET_PIN)
#define RESET_OUTPUT PIN_OUTPUT(RESET_PORT, RESET_PIN)
// General macros. IOCLR registers are 1 cycle when optimised.
#define CTL_INIT() { CD_OUTPUT; CS_OUTPUT; RESET_OUTPUT; SPI_INIT(); }
#define WriteCmd(x) { CD_COMMAND; write8(x); }
#define WriteData(x) { CD_DATA; write16(x); }
libraries/MCUFRIEND_kbv/utility/mcufriend_shield.h
+1231
View File
File diff suppressed because it is too large. Load diff
libraries/MCUFRIEND_kbv/utility/mcufriend_special.h
+1277
View File
File diff suppressed because it is too large. Load diff
libraries/MCUFRIEND_kbv/utility/pin_shield_1.h
+1059
View File
File diff suppressed because it is too large. Load diff
libraries/MCUFRIEND_kbv/utility/pin_shield_8.h
+514
View File
@@ -0,0 +1,514 @@
#ifndef PIN_SHIELD_8_H_
#define PIN_SHIELD_8_H_
// just provide macros for the 8-bit data bus
// i.e. write_8(), read_8(), setWriteDir(), setReadDir()
#define LPC810 810
#define LPC812 812
#define LPC1343 1343
#define LPC1768 1768
#define LPC2103 2103
#define LPC2148 2148
#define ISTARGET_NUCLEO64 (0 \
|| defined(TARGET_NUCLEO_F072RB) \
|| defined(TARGET_NUCLEO_F103RB) \
|| defined(TARGET_NUCLEO_F401RE) \
|| defined(TARGET_NUCLEO_F411RE) \
|| defined(TARGET_NUCLEO_F446RE) \
|| defined(TARGET_NUCLEO_L433RC_P) \
|| defined(TARGET_NUCLEO_L476RG) \
)
#define ISTARGET_NUCLEO144 (0 \
|| defined(TARGET_NUCLEO_F767ZI) \
)
//#warning Using pin_SHIELD_8.h
#if 0
#elif defined(MY_BLUEPILL) // Uno Shield on BLUEPILL_ADAPTER
#warning Uno Shield on MY_BLUEPILL_ADAPTER
// configure macros for the data pins
#define AMASK 0x060F
#define BMASK 0x00C0
#define write_8(d) { GPIOA->BSRR = AMASK << 16; GPIOB->BSRR = BMASK << 16; \
GPIOA->BSRR = (((d) & 3) << 9) | (((d) & 0xF0) >> 4); \
GPIOB->BSRR = (((d) & 0x0C) << 4); \
}
#define read_8() (((GPIOA->IDR & (3<<9)) >> 9) | ((GPIOA->IDR & (0x0F)) << 4) | ((GPIOB->IDR & (3<<6)) >> 4))
#define GROUP_MODE(port, reg, mask, val) {port->reg = (port->reg & ~(mask)) | ((mask)&(val)); }
#define GP_OUT(port, reg, mask) GROUP_MODE(port, reg, mask, 0x33333333)
#define GP_INP(port, reg, mask) GROUP_MODE(port, reg, mask, 0x44444444)
// PA10,PA9 PA3-PA0 PB7,PB6
#define setWriteDir() {GP_OUT(GPIOA, CRH, 0xFF0); GP_OUT(GPIOA, CRL, 0xFFFF); GP_OUT(GPIOB, CRL, 0xFF000000); }
#define setReadDir() {GP_INP(GPIOA, CRH, 0xFF0); GP_INP(GPIOA, CRL, 0xFFFF); GP_INP(GPIOB, CRL, 0xFF000000); }
#elif defined(BLUEPILL) // Uno Shield on BLUEPILL_ADAPTER
#warning Uno Shield on BLUEPILL_ADAPTER
// configure macros for the data pins
#define write_8(d) { GPIOA->BSRR = 0x00FF << 16; GPIOA->BSRR = (d) & 0xFF; }
#define read_8() (GPIOA->IDR & 0xFF)
#define GROUP_MODE(port, reg, mask, val) {port->reg = (port->reg & ~(mask)) | ((mask)&(val)); }
#define GP_OUT(port, reg, mask) GROUP_MODE(port, reg, mask, 0x33333333)
#define GP_INP(port, reg, mask) GROUP_MODE(port, reg, mask, 0x44444444)
// PA7 ..PA0
#define setWriteDir() {GP_OUT(GPIOA, CRL, 0xFFFFFFFF); }
#define setReadDir() {GP_INP(GPIOA, CRL, 0xFFFFFFFF); }
#elif defined(ITEADMAPLE) // Uno Shield on MAPLE_REV3 board
#warning Uno Shield on MAPLE_REV3 board
#define REGS(x) x
#define GROUP_MODE(port, reg, mask, val) {port->REGS(reg) = (port->REGS(reg) & ~(mask)) | ((mask)&(val)); }
#define GP_OUT(port, reg, mask) GROUP_MODE(port, reg, mask, 0x33333333)
#define GP_INP(port, reg, mask) GROUP_MODE(port, reg, mask, 0x44444444)
// configure macros for the data pins
#define write_8(d) { \
GPIOA->REGS(BSRR) = 0x0703 << 16; \
GPIOB->REGS(BSRR) = 0x00E0 << 16; \
GPIOA->REGS(BSRR) = ( ((d) & (1<<0)) << 10) \
| (((d) & (1<<2)) >> 2) \
| (((d) & (1<<3)) >> 2) \
| (((d) & (1<<6)) << 2) \
| (((d) & (1<<7)) << 2); \
GPIOB->REGS(BSRR) = ( ((d) & (1<<1)) << 6) \
| (((d) & (1<<4)) << 1) \
| (((d) & (1<<5)) << 1); \
}
#define read_8() ( ( ( (GPIOA->REGS(IDR) & (1<<10)) >> 10) \
| ((GPIOB->REGS(IDR) & (1<<7)) >> 6) \
| ((GPIOA->REGS(IDR) & (1<<0)) << 2) \
| ((GPIOA->REGS(IDR) & (1<<1)) << 2) \
| ((GPIOB->REGS(IDR) & (1<<5)) >> 1) \
| ((GPIOB->REGS(IDR) & (1<<6)) >> 1) \
| ((GPIOA->REGS(IDR) & (1<<8)) >> 2) \
| ((GPIOA->REGS(IDR) & (1<<9)) >> 2)))
// PA10,PA9,PA8 PA1,PA0 PB7,PB6,PB5
#define setWriteDir() {GP_OUT(GPIOA, CRH, 0xFFF); GP_OUT(GPIOA, CRL, 0xFF); GP_OUT(GPIOB, CRL, 0xFFF00000); }
#define setReadDir() {GP_INP(GPIOA, CRH, 0xFFF); GP_INP(GPIOA, CRL, 0xFF); GP_INP(GPIOB, CRL, 0xFFF00000); }
#elif defined(NUCLEO144) || ISTARGET_NUCLEO144
#if __MBED__
#warning MBED knows everything
#elif defined(STM32F767xx)
#include <STM32F7XX.h>
#endif
#define REGS(x) x
// configure macros for the data pins
#define DMASK ((1<<15)) //#1
#define EMASK ((1<<13)|(1<<11)|(1<<9)) //#3, #5, #6
#define FMASK ((1<<12)|(1<<15)|(1<<14)|(1<<13)) //#0, #2, #4, #7
#define write_8(d) { \
GPIOD->REGS(BSRR) = DMASK << 16; \
GPIOE->REGS(BSRR) = EMASK << 16; \
GPIOF->REGS(BSRR) = FMASK << 16; \
GPIOD->REGS(BSRR) = ( ((d) & (1<<1)) << 14); \
GPIOE->REGS(BSRR) = ( ((d) & (1<<3)) << 10) \
| (((d) & (1<<5)) << 6) \
| (((d) & (1<<6)) << 3); \
GPIOF->REGS(BSRR) = ( ((d) & (1<<0)) << 12) \
| (((d) & (1<<2)) << 13) \
| (((d) & (1<<4)) << 10) \
| (((d) & (1<<7)) << 6); \
}
#define read_8() ( ( ( (GPIOF->REGS(IDR) & (1<<12)) >> 12) \
| ((GPIOD->REGS(IDR) & (1<<15)) >> 14) \
| ((GPIOF->REGS(IDR) & (1<<15)) >> 13) \
| ((GPIOE->REGS(IDR) & (1<<13)) >> 10) \
| ((GPIOF->REGS(IDR) & (1<<14)) >> 10) \
| ((GPIOE->REGS(IDR) & (1<<11)) >> 6) \
| ((GPIOE->REGS(IDR) & (1<<9)) >> 3) \
| ((GPIOF->REGS(IDR) & (1<<13)) >> 6)))
// PD15 PE13,PE11,PE9 PF15,PF14,PF13,PF12
#define setWriteDir() { setReadDir(); \
GPIOD->MODER |= 0x40000000; GPIOE->MODER |= 0x04440000; GPIOF->MODER |= 0x55000000; }
#define setReadDir() { GPIOD->MODER &= ~0xC0000000; GPIOE->MODER &= ~0x0CCC0000; GPIOF->MODER &= ~0xFF000000; }
#elif defined(NUCLEO) || ISTARGET_NUCLEO64
#if __MBED__
#warning MBED knows everything
#elif defined(STM32F072xB)
#include <STM32F0XX.h>
#elif defined(STM32F103xB)
#if defined(__CC_ARM)
#include <STM32F10X.h>
#else
#include <STM32F1XX.h>
#endif
#elif defined(STM32L476xx) || defined(STM32L433xx)
#include <STM32L4XX.h>
#elif defined(STM32F401xE) || defined(STM32F411xE) || defined(STM32F446xx)
#include <STM32F4XX.h>
#endif
// configure macros for the data pins. -00=10.06, -O1=7.85, -O1t=7.21, -O2=7.87, -O3=7.45, -O3t=7.03
#define write_8(d) { \
GPIOA->BSRR = 0x0700 << 16; \
GPIOB->BSRR = 0x0438 << 16; \
GPIOC->BSRR = 0x0080 << 16; \
GPIOA->BSRR = (((d) & (1<<0)) << 9) \
| (((d) & (1<<2)) << 8) \
| (((d) & (1<<7)) << 1); \
GPIOB->BSRR = (((d) & (1<<3)) << 0) \
| (((d) & (1<<4)) << 1) \
| (((d) & (1<<5)) >> 1) \
| (((d) & (1<<6)) << 4); \
GPIOC->BSRR = (((d) & (1<<1)) << 6); \
}
#define read_8() ( (((GPIOA->IDR & (1<<9)) >> 9) \
| ((GPIOC->IDR & (1<<7)) >> 6) \
| ((GPIOA->IDR & (1<<10)) >> 8) \
| ((GPIOB->IDR & (1<<3)) >> 0) \
| ((GPIOB->IDR & (1<<5)) >> 1) \
| ((GPIOB->IDR & (1<<4)) << 1) \
| ((GPIOB->IDR & (1<<10)) >> 4) \
| ((GPIOA->IDR & (1<<8)) >> 1)))
// be wise to clear both MODER bits properly.
#if defined(STM32F103xB)
#define GROUP_MODE(port, reg, mask, val) {port->reg = (port->reg & ~(mask)) | ((mask)&(val)); }
#define GP_OUT(port, reg, mask) GROUP_MODE(port, reg, mask, 0x33333333)
#define GP_INP(port, reg, mask) GROUP_MODE(port, reg, mask, 0x44444444)
// PA10,PA9,PA8 PB10 PB5,PB4,PB3 PC7
#define setWriteDir() {GP_OUT(GPIOA, CRH, 0xFFF); GP_OUT(GPIOB, CRH, 0xF00); GP_OUT(GPIOB, CRL, 0xFFF000); GP_OUT(GPIOC, CRL, 0xF0000000); }
#define setReadDir() {GP_INP(GPIOA, CRH, 0xFFF); GP_INP(GPIOB, CRH, 0xF00); GP_INP(GPIOB, CRL, 0xFFF000); GP_INP(GPIOC, CRL, 0xF0000000); }
#else
#define setWriteDir() { setReadDir(); \
GPIOA->MODER |= 0x150000; GPIOB->MODER |= 0x100540; GPIOC->MODER |= 0x4000; }
#define setReadDir() { GPIOA->MODER &= ~0x3F0000; GPIOB->MODER &= ~0x300FC0; GPIOC->MODER &= ~0xC000; }
#endif
#elif __TARGET_PROCESSOR == LPC1768
#include <LPC17xx.h>
// configure macros for the data pins
#define write_8(d) { \
LPC_GPIO0->FIOPIN = (LPC_GPIO0->FIOPIN & ~0x01878003) \
| (((d) & (1<<0)) << 1) \
| (((d) & (1<<1)) >> 1) \
| (((d) & (1<<2)) << 22) \
| (((d) & (1<<3)) << 20) \
| (((d) & (1<<4)) << 12) \
| (((d) & (1<<5)) << 10) \
| (((d) & (1<<6)) << 11) \
| (((d) & (1<<7)) << 11); \
}
#define read_8() ( (((LPC_GPIO0->FIOPIN & (1<<1)) >> 1) \
| ((LPC_GPIO0->FIOPIN & (1<<0)) << 1) \
| ((LPC_GPIO0->FIOPIN & (1<<24)) >> 22) \
| ((LPC_GPIO0->FIOPIN & (1<<23)) >> 20) \
| ((LPC_GPIO0->FIOPIN & (1<<16)) >> 12) \
| ((LPC_GPIO0->FIOPIN & (1<<15)) >> 10) \
| ((LPC_GPIO0->FIOPIN & (1<<17)) >> 11) \
| ((LPC_GPIO0->FIOPIN & (1<<18)) >> 11)))
#define setWriteDir() {LPC_GPIO0->FIODIR |= 0x01878003; }
#define setReadDir() {LPC_GPIO0->FIODIR &= ~0x01878003; }
#elif defined(MKL25Z4) || defined(TARGET_KL25Z)
#include <MKL25Z4.h>
// configure macros for the data pins
#if 1
#define AMASK ((1<<13)|(1<<12)|(1<<5)|(1<<4))
#define CMASK ((1<<9)|(1<<8))
#define DMASK ((1<<5)|(1<<4))
#define write_8(d) { \
PTA->PCOR = AMASK; PTC->PCOR = CMASK; PTD->PCOR = DMASK; \
PTA->PSOR = (((d) & (1<<0)) << 13) \
| (((d) & (1<<3)) << 9) \
| (((d) & (1<<4)) >> 0) \
| (((d) & (1<<5)) >> 0); \
PTC->PSOR = (((d) & (1<<6)) << 2) \
| (((d) & (1<<7)) << 2); \
PTD->PSOR = (((d) & (1<<1)) << 4) \
| (((d) & (1<<2)) << 2); \
}
#define read_8() ( (((PTA->PDIR & (1<<13)) >> 13) \
| ((PTA->PDIR & (1<<12)) >> 9) \
| ((PTA->PDIR & (3<<4)) >> 0) \
| ((PTC->PDIR & (3<<8)) >> 2) \
| ((PTD->PDIR & (1<<4)) >> 2) \
| ((PTD->PDIR & (1<<5)) >> 4)))
#define setWriteDir() {PTA->PDDR |= AMASK;PTC->PDDR |= CMASK;PTD->PDDR |= DMASK; }
#define setReadDir() {PTA->PDDR &= ~AMASK;PTC->PDDR &= ~CMASK;PTD->PDDR &= ~DMASK; }
#else
#define write_8(d) { \
PTA->PDOR = (PTA->PDOR & ~0x3030) \
| (((d) & (1<<0)) << 13) \
| (((d) & (1<<3)) << 9) \
| (((d) & (3<<4)) << 0); \
PTC->PDOR = (PTC->PDOR & ~0x0300) \
| (((d) & (3<<6)) << 2); \
PTD->PDOR = (PTD->PDOR & ~0x0030) \
| (((d) & (1<<1)) << 4) \
| (((d) & (1<<2)) << 2); \
}
#define read_8() ( (((PTA->PDIR & (1<<13)) >> 13) \
| ((PTA->PDIR & (1<<12)) >> 9) \
| ((PTA->PDIR & (3<<4)) >> 0) \
| ((PTC->PDIR & (3<<8)) >> 2) \
| ((PTD->PDIR & (1<<4)) >> 2) \
| ((PTD->PDIR & (1<<5)) >> 4)))
#define setWriteDir() {PTA->PDDR |= 0x3030;PTC->PDDR |= 0x0300;PTD->PDDR |= 0x0030; }
#define setReadDir() {PTA->PDDR &= ~0x3030;PTC->PDDR &= ~0x0300;PTD->PDDR &= ~0x0030; }
#endif
#elif defined(MKL26Z4)
#include <MKL26Z4.h>
// configure macros for the data pins
#define AMASK ((1<<13)|(1<<12)|(1<<5)|(1<<4))
#define CMASK ((1<<9)|(1<<8))
#define DMASK ((1<<3)|(1<<2)) //PTD5, PTD4 on KL25Z
#define write_8(d) { \
PTA->PCOR = AMASK; PTC->PCOR = CMASK; PTD->PCOR = DMASK; \
PTA->PSOR = (((d) & (1<<0)) << 13) \
| (((d) & (1<<3)) << 9) \
| (((d) & (1<<4)) >> 0) \
| (((d) & (1<<5)) >> 0); \
PTC->PSOR = (((d) & (1<<6)) << 2) \
| (((d) & (1<<7)) << 2); \
PTD->PSOR = (((d) & (1<<1)) << 1) \
| (((d) & (1<<2)) << 1); \
}
#define read_8() ( (((PTA->PDIR & (1<<13)) >> 13) \
| ((PTA->PDIR & (1<<12)) >> 9) \
| ((PTA->PDIR & (3<<4)) >> 0) \
| ((PTC->PDIR & (3<<8)) >> 2) \
| ((PTD->PDIR & (1<<3)) >> 1) \
| ((PTD->PDIR & (1<<2)) >> 1)))
#define setWriteDir() {PTA->PDDR |= AMASK;PTC->PDDR |= CMASK;PTD->PDDR |= DMASK; }
#define setReadDir() {PTA->PDDR &= ~AMASK;PTC->PDDR &= ~CMASK;PTD->PDDR &= ~DMASK; }
#elif defined(MKL05Z4) || defined(TARGET_KL05Z)
#include <MKL05Z4.h>
// configure macros for the data pins
#define write_8(d) { \
PTA->PDOR = (PTA->PDOR & ~0x1C00) \
| (((d) & (1<<2)) << 9) \
| (((d) & (1<<4)) << 6) \
| (((d) & (1<<5)) << 7); \
PTB->PDOR = (PTB->PDOR & ~0x0CE0) \
| (((d) & (3<<0)) << 10) \
| (((d) & (1<<3)) << 2) \
| (((d) & (3<<6)) << 0); \
}
#define read_8() ( (((PTA->PDIR & (1<<11)) >> 9) \
| ((PTA->PDIR & (1<<10)) >> 6) \
| ((PTA->PDIR & (1<<12)) >> 7) \
| ((PTB->PDIR & (3<<10)) >> 10) \
| ((PTB->PDIR & (1<<5)) >> 2) \
| ((PTB->PDIR & (3<<6)) >> 0)))
#define setWriteDir() { PTA->PDDR |= 0x1C00; PTB->PDDR |= 0x0CE0; }
#define setReadDir() { PTA->PDDR &= ~0x1C00; PTB->PDDR &= ~0x0CE0; }
#elif (defined(MK20D7) && defined(TEENSY)) || defined(TARGET_TEENSY3_1)
#if __MBED__
#warning MBED knows everything
#else
#include <MK20D5.h>
#endif
// configure macros for the data pins
#define AMASK ((1<<12)|(1<<13))
#define CMASK ((1<<3))
#define DMASK ((1<<0)|(1<<2)|(1<<3)|(1<<4)|(1<<7))
#define write_8(d) { \
PTA->PCOR = AMASK; PTC->PCOR = CMASK; PTD->PCOR = DMASK; \
PTA->PSOR = (((d) & (1<<3)) << 9) \
| (((d) & (1<<4)) << 9); \
PTC->PSOR = (((d) & (1<<1)) << 2); \
PTD->PSOR = (((d) & (1<<0)) << 3) \
| (((d) & (1<<2)) >> 2) \
| (((d) & (1<<5)) << 2) \
| (((d) & (1<<6)) >> 2) \
| (((d) & (1<<7)) >> 5); \
}
#define read_8() ( (((PTD->PDIR & (1<<3)) >> 3) \
| ((PTC->PDIR & (1<<3)) >> 2) \
| ((PTD->PDIR & (1<<0)) << 2) \
| ((PTA->PDIR & (1<<12)) >> 9) \
| ((PTA->PDIR & (1<<13)) >> 9) \
| ((PTD->PDIR & (1<<7)) >> 2) \
| ((PTD->PDIR & (1<<4)) << 2) \
| ((PTD->PDIR & (1<<2)) << 5)))
#define setWriteDir() {PTA->PDDR |= AMASK;PTC->PDDR |= CMASK;PTD->PDDR |= DMASK; }
#define setReadDir() {PTA->PDDR &= ~AMASK;PTC->PDDR &= ~CMASK;PTD->PDDR &= ~DMASK; }
#elif defined(MK20D5) || defined(TARGET_K20D50M)
#include <MK20D5.h>
// configure macros for the data pins
#define AMASK ((1<<12)|(1<<5)|(1<<2)|(1<<1))
#define CMASK ((1<<8)|(1<<4)|(1<<3))
#define DMASK ((1<<4))
#define write_8(d) { \
PTA->PCOR = AMASK; PTC->PCOR = CMASK; PTD->PCOR = DMASK; \
PTA->PSOR = (((d) & (1<<0)) << 12) \
| (((d) & (1<<1)) << 1) \
| (((d) & (1<<2)) << 3) \
| (((d) & (1<<5)) >> 4); \
PTC->PSOR = (((d) & (1<<4)) << 4) \
| (((d) & (3<<6)) >> 3); \
PTD->PSOR = (((d) & (1<<3)) << 1); \
}
#define read_8() ( (((PTA->PDIR & (1<<5)) >> 3) \
| ((PTA->PDIR & (1<<1)) << 4) \
| ((PTA->PDIR & (1<<12)) >> 12) \
| ((PTA->PDIR & (1<<2)) >> 1) \
| ((PTC->PDIR & (1<<8)) >> 4) \
| ((PTC->PDIR & (3<<3)) << 3) \
| ((PTD->PDIR & (1<<4)) >> 1)))
#define setWriteDir() {PTA->PDDR |= AMASK;PTC->PDDR |= CMASK;PTD->PDDR |= DMASK; }
#define setReadDir() {PTA->PDDR &= ~AMASK;PTC->PDDR &= ~CMASK;PTD->PDDR &= ~DMASK; }
#elif defined(ZERO)
#include <samd21.h>
#ifndef PORTA
#define PORTA PORT->Group[0]
#define PORTB PORT->Group[1]
#endif
// configure macros for the data pins
#if defined(D21_XPRO)
#define AMASK 0x00220000
#define BMASK 0x0000C0E4
#define WRMASK ((0<<22) | (1<<28) | (1<<30)) //
#define RDMASK ((1<<17) | (1<<28) | (1<<30)) //
#define write_8(d) { \
PORTA.OUTCLR.reg = AMASK; PORTB.OUTCLR.reg = BMASK; \
PORTA.OUTSET.reg = 0 \
| (((d) & (1<<5)) << 16) \
| (((d) & (1<<7)) << 10); \
PORTB.OUTSET.reg = 0 \
| (((d) & (3<<0)) << 6) \
| (((d) & (1<<2)) << 12) \
| (((d) & (1<<3)) >> 1) \
| (((d) & (1<<4)) << 1) \
| (((d) & (1<<6)) << 9); \
}
#define read_8() ( (((PORTA.IN.reg & (1<<21)) >> 16) \
| ((PORTA.IN.reg & (1<<17)) >> 10) \
| ((PORTB.IN.reg & (3<<6)) >> 6) \
| ((PORTB.IN.reg & (1<<14)) >> 12) \
| ((PORTB.IN.reg & (1<<2)) << 1) \
| ((PORTB.IN.reg & (1<<5)) >> 1) \
| ((PORTB.IN.reg & (1<<15)) >> 9)))
#define setWriteDir() { \
PORTA.DIRSET.reg = AMASK; \
PORTB.DIRSET.reg = BMASK; \
PORTA.WRCONFIG.reg = (AMASK>>16) | WRMASK | (1<<31); \
PORTB.WRCONFIG.reg = (BMASK & 0xFFFF) | WRMASK; \
}
#define setReadDir() { \
PORTA.DIRCLR.reg = AMASK; \
PORTB.DIRCLR.reg = BMASK; \
PORTA.WRCONFIG.reg = (AMASK>>16) | RDMASK | (1<<31); \
PORTB.WRCONFIG.reg = (BMASK & 0xFFFF) | RDMASK; \
}
#elif defined(M0_PRO)
#define DMASK 0x0030C3C0
#define WRMASK ((0<<22) | (1<<28) | (1<<30)) //
#define RDMASK ((1<<17) | (1<<28) | (1<<30)) //
#define write_8(x) {PORTA.OUTCLR.reg = (DMASK); \
PORTA.OUTSET.reg = (((x) & 0x0F) << 6) \
| (((x) & 0x30) << 10) \
| (((x) & 0xC0)<<14); }
#define read_8() (((PORTA.IN.reg >> 6) & 0x0F) \
| ((PORTA.IN.reg >> 10) & 0x30) \
| ((PORTA.IN.reg >> 14) & 0xC0))
#define setWriteDir() { PORTA.DIRSET.reg = DMASK; \
PORTA.WRCONFIG.reg = (DMASK & 0xFFFF) | WRMASK; \
PORTA.WRCONFIG.reg = (DMASK>>16) | WRMASK | (1<<31); \
}
#define setReadDir() { PORTA.DIRCLR.reg = DMASK; \
PORTA.WRCONFIG.reg = (DMASK & 0xFFFF) | RDMASK; \
PORTA.WRCONFIG.reg = (DMASK>>16) | RDMASK | (1<<31); \
}
#endif
//############################# SAM4S_XPRO ############################
#elif defined(SAM4S_XPRO)
// configure macros for data bus
#define AMASK ((1<<9)|(1<<6)|(1<<23)|(1<<25)|(1<<24))
#define CMASK ((1<<25)|(1<<26)|(1<<27))
#define write_8(d) { \
PIOA->PIO_CODR = AMASK; PIOC->PIO_CODR = CMASK; \
PIOA->PIO_SODR = 0 \
| (((d) & (3<<0)) << 24) \
| (((d) & (1<<3)) << 20) \
| (((d) & (1<<4)) << 2) \
| (((d) & (1<<7)) << 2); \
PIOC->PIO_SODR = 0 \
| (((d) & (1<<2)) << 24) \
| (((d) & (1<<5)) << 20) \
| (((d) & (1<<6)) << 21); \
}
#define read_8() ( (((PIOA->PIO_PDSR & (1<<24)) >> 24) \
| ((PIOA->PIO_PDSR & (1<<25)) >> 24) \
| ((PIOC->PIO_PDSR & (1<<26)) >> 24) \
| ((PIOA->PIO_PDSR & (1<<23)) >> 20) \
| ((PIOA->PIO_PDSR & (1<<6)) >> 2) \
| ((PIOC->PIO_PDSR & (1<<25)) >> 20) \
| ((PIOC->PIO_PDSR & (1<<27)) >> 21) \
| ((PIOA->PIO_PDSR & (1<<9)) >> 2) \
))
#define setWriteDir() { \
PIOA->PIO_OER = AMASK; \
PIOC->PIO_OER = CMASK; \
}
#define setReadDir() { \
PMC->PMC_PCER0 = (1 << ID_PIOA)|(1 << ID_PIOC);\
PIOA->PIO_ODR = AMASK; PIOC->PIO_ODR = CMASK;\
}
//####################################### DUE ############################
#elif defined(__SAM3X8E__) //regular UNO shield on DUE
// configure macros for data bus
#define BMASK (1<<25)
#define CMASK (0xBF << 21)
#define write_8(x) { PIOB->PIO_CODR = BMASK; PIOC->PIO_CODR = CMASK; \
PIOB->PIO_SODR = (((x) & (1<<2)) << 23); \
PIOC->PIO_SODR = (((x) & (1<<0)) << 22) \
| (((x) & (1<<1)) << 20) \
| (((x) & (1<<3)) << 25) \
| (((x) & (1<<4)) << 22) \
| (((x) & (1<<5)) << 20) \
| (((x) & (1<<6)) << 18) \
| (((x) & (1<<7)) << 16); \
}
#define read_8() ( ((PIOC->PIO_PDSR & (1<<22)) >> 22)\
| ((PIOC->PIO_PDSR & (1<<21)) >> 20)\
| ((PIOB->PIO_PDSR & (1<<25)) >> 23)\
| ((PIOC->PIO_PDSR & (1<<28)) >> 25)\
| ((PIOC->PIO_PDSR & (1<<26)) >> 22)\
| ((PIOC->PIO_PDSR & (1<<25)) >> 20)\
| ((PIOC->PIO_PDSR & (1<<24)) >> 18)\
| ((PIOC->PIO_PDSR & (1<<23)) >> 16)\
)
#define setWriteDir() { PIOB->PIO_OER = BMASK; PIOC->PIO_OER = CMASK; }
#define setReadDir() { \
PMC->PMC_PCER0 = (1 << ID_PIOB)|(1 << ID_PIOC);\
PIOB->PIO_ODR = BMASK; PIOC->PIO_ODR = CMASK;\
}
#else
#error MCU unselected
#endif // MCUs
#endif //PIN_SHIELD_8_H