можно конечно. хоть как то решить это. так это нужно в моем шрифте перерисовывать получается. я так понимю вот это { 21, 14, 24, 16, 1, -23 }, // 0x23 '#'
/*
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 "Adafruit_GFX.h"
#include "glcdfont.c"
#ifdef __AVR__
#include <avr/pgmspace.h>
#elif defined(ESP8266) || defined(ESP32)
#include <pgmspace.h>
#endif
// Many (but maybe not all) non-AVR board installs define macros
// for compatibility with existing PROGMEM-reading AVR code.
// Do our own checks and defines here for good measure...
#ifndef pgm_read_byte
#define pgm_read_byte(addr) (*(const unsigned char *)(addr))
#endif
#ifndef pgm_read_word
#define pgm_read_word(addr) (*(const unsigned short *)(addr))
#endif
#ifndef pgm_read_dword
#define pgm_read_dword(addr) (*(const unsigned long *)(addr))
#endif
// Pointers are a peculiar case...typically 16-bit on AVR boards,
// 32 bits elsewhere. Try to accommodate both...
#if !defined(__INT_MAX__) || (__INT_MAX__ > 0xFFFF)
#define pgm_read_pointer(addr) ((void *)pgm_read_dword(addr))
#else
#define pgm_read_pointer(addr) ((void *)pgm_read_word(addr))
#endif
#ifndef min
#define min(a,b) (((a) < (b)) ? (a) : (b))
#endif
#ifndef _swap_int16_t
#define _swap_int16_t(a, b) { int16_t t = a; a = b; b = t; }
#endif
/**************************************************************************/
/*!
@brief Instatiate a GFX context for graphics! Can only be done by a superclass
@param w Display width, in pixels
@param h Display height, in pixels
*/
/**************************************************************************/
Adafruit_GFX::Adafruit_GFX(int16_t w, int16_t h):
WIDTH(w), HEIGHT(h)
{
_width = WIDTH;
_height = HEIGHT;
rotation = 0;
cursor_y = cursor_x = 0;
textsize = 1;
textcolor = textbgcolor = 0xFFFF;
wrap = true;
_cp437 = false;
gfxFont = NULL;
}
/**************************************************************************/
/*!
@brief Write a line. Bresenham's algorithm - thx wikpedia
@param x0 Start point x coordinate
@param y0 Start point y coordinate
@param x1 End point x coordinate
@param y1 End point y coordinate
@param color 16-bit 5-6-5 Color to draw with
*/
/**************************************************************************/
void Adafruit_GFX::writeLine(int16_t x0, int16_t y0, int16_t x1, int16_t y1,
uint16_t color) {
#if defined(ESP8266)
yield();
#endif
int16_t steep = abs(y1 - y0) > abs(x1 - x0);
if (steep) {
_swap_int16_t(x0, y0);
_swap_int16_t(x1, y1);
}
if (x0 > x1) {
_swap_int16_t(x0, x1);
_swap_int16_t(y0, y1);
}
int16_t dx, dy;
dx = x1 - x0;
dy = abs(y1 - y0);
int16_t err = dx / 2;
int16_t ystep;
if (y0 < y1) {
ystep = 1;
} else {
ystep = -1;
}
for (; x0<=x1; x0++) {
if (steep) {
writePixel(y0, x0, color);
} else {
writePixel(x0, y0, color);
}
err -= dy;
if (err < 0) {
y0 += ystep;
err += dx;
}
}
}
/**************************************************************************/
/*!
@brief Start a display-writing routine, overwrite in subclasses.
*/
/**************************************************************************/
void Adafruit_GFX::startWrite(){
}
/**************************************************************************/
/*!
@brief Write a pixel, overwrite in subclasses if startWrite is defined!
@param x x coordinate
@param y y coordinate
@param color 16-bit 5-6-5 Color to fill with
*/
/**************************************************************************/
void Adafruit_GFX::writePixel(int16_t x, int16_t y, uint16_t color){
drawPixel(x, y, color);
}
/**************************************************************************/
/*!
@brief Write a perfectly vertical line, overwrite in subclasses if startWrite is defined!
@param x Top-most x coordinate
@param y Top-most y coordinate
@param h Height in pixels
@param color 16-bit 5-6-5 Color to fill with
*/
/**************************************************************************/
void Adafruit_GFX::writeFastVLine(int16_t x, int16_t y,
int16_t h, uint16_t color) {
// Overwrite in subclasses if startWrite is defined!
// Can be just writeLine(x, y, x, y+h-1, color);
// or writeFillRect(x, y, 1, h, color);
drawFastVLine(x, y, h, color);
}
/**************************************************************************/
/*!
@brief Write a perfectly horizontal line, overwrite in subclasses if startWrite is defined!
@param x Left-most x coordinate
@param y Left-most y coordinate
@param w Width in pixels
@param color 16-bit 5-6-5 Color to fill with
*/
/**************************************************************************/
void Adafruit_GFX::writeFastHLine(int16_t x, int16_t y,
int16_t w, uint16_t color) {
// Overwrite in subclasses if startWrite is defined!
// Example: writeLine(x, y, x+w-1, y, color);
// or writeFillRect(x, y, w, 1, color);
drawFastHLine(x, y, w, color);
}
/**************************************************************************/
/*!
@brief Write a rectangle completely with one color, overwrite in subclasses if startWrite is defined!
@param x Top left corner x coordinate
@param y Top left corner y coordinate
@param w Width in pixels
@param h Height in pixels
@param color 16-bit 5-6-5 Color to fill with
*/
/**************************************************************************/
void Adafruit_GFX::writeFillRect(int16_t x, int16_t y, int16_t w, int16_t h,
uint16_t color) {
// Overwrite in subclasses if desired!
fillRect(x,y,w,h,color);
}
/**************************************************************************/
/*!
@brief End a display-writing routine, overwrite in subclasses if startWrite is defined!
*/
/**************************************************************************/
void Adafruit_GFX::endWrite(){
}
/**************************************************************************/
/*!
@brief Draw a perfectly vertical line (this is often optimized in a subclass!)
@param x Top-most x coordinate
@param y Top-most y coordinate
@param h Height in pixels
@param color 16-bit 5-6-5 Color to fill with
*/
/**************************************************************************/
void Adafruit_GFX::drawFastVLine(int16_t x, int16_t y,
int16_t h, uint16_t color) {
startWrite();
writeLine(x, y, x, y+h-1, color);
endWrite();
}
/**************************************************************************/
/*!
@brief Draw a perfectly horizontal line (this is often optimized in a subclass!)
@param x Left-most x coordinate
@param y Left-most y coordinate
@param w Width in pixels
@param color 16-bit 5-6-5 Color to fill with
*/
/**************************************************************************/
void Adafruit_GFX::drawFastHLine(int16_t x, int16_t y,
int16_t w, uint16_t color) {
startWrite();
writeLine(x, y, x+w-1, y, color);
endWrite();
}
/**************************************************************************/
/*!
@brief Fill a rectangle completely with one color. Update in subclasses if desired!
@param x Top left corner x coordinate
@param y Top left corner y coordinate
@param w Width in pixels
@param h Height in pixels
@param color 16-bit 5-6-5 Color to fill with
*/
/**************************************************************************/
void Adafruit_GFX::fillRect(int16_t x, int16_t y, int16_t w, int16_t h,
uint16_t color) {
startWrite();
for (int16_t i=x; i<x+w; i++) {
writeFastVLine(i, y, h, color);
}
endWrite();
}
/**************************************************************************/
/*!
@brief Fill the screen completely with one color. Update in subclasses if desired!
@param color 16-bit 5-6-5 Color to fill with
*/
/**************************************************************************/
void Adafruit_GFX::fillScreen(uint16_t color) {
fillRect(0, 0, _width, _height, color);
}
/**************************************************************************/
/*!
@brief Draw a line
@param x0 Start point x coordinate
@param y0 Start point y coordinate
@param x1 End point x coordinate
@param y1 End point y coordinate
@param color 16-bit 5-6-5 Color to draw with
*/
/**************************************************************************/
void Adafruit_GFX::drawLine(int16_t x0, int16_t y0, int16_t x1, int16_t y1,
uint16_t color) {
// Update in subclasses if desired!
if(x0 == x1){
if(y0 > y1) _swap_int16_t(y0, y1);
drawFastVLine(x0, y0, y1 - y0 + 1, color);
} else if(y0 == y1){
if(x0 > x1) _swap_int16_t(x0, x1);
drawFastHLine(x0, y0, x1 - x0 + 1, color);
} else {
startWrite();
writeLine(x0, y0, x1, y1, color);
endWrite();
}
}
/**************************************************************************/
/*!
@brief Draw a circle outline
@param x0 Center-point x coordinate
@param y0 Center-point y coordinate
@param r Radius of circle
@param color 16-bit 5-6-5 Color to draw with
*/
/**************************************************************************/
void Adafruit_GFX::drawCircle(int16_t x0, int16_t y0, int16_t r,
uint16_t color) {
#if defined(ESP8266)
yield();
#endif
int16_t f = 1 - r;
int16_t ddF_x = 1;
int16_t ddF_y = -2 * r;
int16_t x = 0;
int16_t y = r;
startWrite();
writePixel(x0 , y0+r, color);
writePixel(x0 , y0-r, color);
writePixel(x0+r, y0 , color);
writePixel(x0-r, y0 , color);
while (x<y) {
if (f >= 0) {
y--;
ddF_y += 2;
f += ddF_y;
}
x++;
ddF_x += 2;
f += ddF_x;
writePixel(x0 + x, y0 + y, color);
writePixel(x0 - x, y0 + y, color);
writePixel(x0 + x, y0 - y, color);
writePixel(x0 - x, y0 - y, color);
writePixel(x0 + y, y0 + x, color);
writePixel(x0 - y, y0 + x, color);
writePixel(x0 + y, y0 - x, color);
writePixel(x0 - y, y0 - x, color);
}
endWrite();
}
/**************************************************************************/
/*!
@brief Quarter-circle drawer, used to do circles and roundrects
@param x0 Center-point x coordinate
@param y0 Center-point y coordinate
@param r Radius of circle
@param cornername Mask bit #1 or bit #2 to indicate which quarters of the circle we're doing
@param color 16-bit 5-6-5 Color to draw with
*/
/**************************************************************************/
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) {
writePixel(x0 + x, y0 + y, color);
writePixel(x0 + y, y0 + x, color);
}
if (cornername & 0x2) {
writePixel(x0 + x, y0 - y, color);
writePixel(x0 + y, y0 - x, color);
}
if (cornername & 0x8) {
writePixel(x0 - y, y0 + x, color);
writePixel(x0 - x, y0 + y, color);
}
if (cornername & 0x1) {
writePixel(x0 - y, y0 - x, color);
writePixel(x0 - x, y0 - y, color);
}
}
}
/**************************************************************************/
/*!
@brief Draw a circle with filled color
@param x0 Center-point x coordinate
@param y0 Center-point y coordinate
@param r Radius of circle
@param color 16-bit 5-6-5 Color to fill with
*/
/**************************************************************************/
void Adafruit_GFX::fillCircle(int16_t x0, int16_t y0, int16_t r,
uint16_t color) {
startWrite();
writeFastVLine(x0, y0-r, 2*r+1, color);
fillCircleHelper(x0, y0, r, 3, 0, color);
endWrite();
}
/**************************************************************************/
/*!
@brief Quarter-circle drawer with fill, used for circles and roundrects
@param x0 Center-point x coordinate
@param y0 Center-point y coordinate
@param r Radius of circle
@param corners Mask bits indicating which quarters we're doing
@param delta Offset from center-point, used for round-rects
@param color 16-bit 5-6-5 Color to fill with
*/
/**************************************************************************/
void Adafruit_GFX::fillCircleHelper(int16_t x0, int16_t y0, int16_t r,
uint8_t corners, 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;
int16_t px = x;
int16_t py = y;
delta++; // Avoid some +1's in the loop
while(x < y) {
if (f >= 0) {
y--;
ddF_y += 2;
f += ddF_y;
}
x++;
ddF_x += 2;
f += ddF_x;
// These checks avoid double-drawing certain lines, important
// for the SSD1306 library which has an INVERT drawing mode.
if(x < (y + 1)) {
if(corners & 1) writeFastVLine(x0+x, y0-y, 2*y+delta, color);
if(corners & 2) writeFastVLine(x0-x, y0-y, 2*y+delta, color);
}
if(y != py) {
if(corners & 1) writeFastVLine(x0+py, y0-px, 2*px+delta, color);
if(corners & 2) writeFastVLine(x0-py, y0-px, 2*px+delta, color);
py = y;
}
px = x;
}
}
/**************************************************************************/
/*!
@brief Draw a rectangle with no fill color
@param x Top left corner x coordinate
@param y Top left corner y coordinate
@param w Width in pixels
@param h Height in pixels
@param color 16-bit 5-6-5 Color to draw with
*/
/**************************************************************************/
void Adafruit_GFX::drawRect(int16_t x, int16_t y, int16_t w, int16_t h,
uint16_t color) {
startWrite();
writeFastHLine(x, y, w, color);
writeFastHLine(x, y+h-1, w, color);
writeFastVLine(x, y, h, color);
writeFastVLine(x+w-1, y, h, color);
endWrite();
}
/**************************************************************************/
/*!
@brief Draw a rounded rectangle with no fill color
@param x Top left corner x coordinate
@param y Top left corner y coordinate
@param w Width in pixels
@param h Height in pixels
@param r Radius of corner rounding
@param color 16-bit 5-6-5 Color to draw with
*/
/**************************************************************************/
void Adafruit_GFX::drawRoundRect(int16_t x, int16_t y, int16_t w,
int16_t h, int16_t r, uint16_t color) {
int16_t max_radius = ((w < h) ? w : h) / 2; // 1/2 minor axis
if(r > max_radius) r = max_radius;
// smarter version
startWrite();
writeFastHLine(x+r , y , w-2*r, color); // Top
writeFastHLine(x+r , y+h-1, w-2*r, color); // Bottom
writeFastVLine(x , y+r , h-2*r, color); // Left
writeFastVLine(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);
endWrite();
}
/**************************************************************************/
/*!
@brief Draw a rounded rectangle with fill color
@param x Top left corner x coordinate
@param y Top left corner y coordinate
@param w Width in pixels
@param h Height in pixels
@param r Radius of corner rounding
@param color 16-bit 5-6-5 Color to draw/fill with
*/
/**************************************************************************/
void Adafruit_GFX::fillRoundRect(int16_t x, int16_t y, int16_t w,
int16_t h, int16_t r, uint16_t color) {
int16_t max_radius = ((w < h) ? w : h) / 2; // 1/2 minor axis
if(r > max_radius) r = max_radius;
// smarter version
startWrite();
writeFillRect(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);
endWrite();
}
/**************************************************************************/
/*!
@brief Draw a triangle with no fill color
@param x0 Vertex #0 x coordinate
@param y0 Vertex #0 y coordinate
@param x1 Vertex #1 x coordinate
@param y1 Vertex #1 y coordinate
@param x2 Vertex #2 x coordinate
@param y2 Vertex #2 y coordinate
@param color 16-bit 5-6-5 Color to draw with
*/
/**************************************************************************/
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);
}
/**************************************************************************/
/*!
@brief Draw a triangle with color-fill
@param x0 Vertex #0 x coordinate
@param y0 Vertex #0 y coordinate
@param x1 Vertex #1 x coordinate
@param y1 Vertex #1 y coordinate
@param x2 Vertex #2 x coordinate
@param y2 Vertex #2 y coordinate
@param color 16-bit 5-6-5 Color to fill/draw with
*/
/**************************************************************************/
void Adafruit_GFX::fillTriangle(int16_t x0, int16_t y0,
int16_t x1, int16_t y1, int16_t x2, int16_t y2, uint16_t color) {
int16_t a, b, y, last;
// Sort coordinates by Y order (y2 >= y1 >= y0)
if (y0 > y1) {
_swap_int16_t(y0, y1); _swap_int16_t(x0, x1);
}
if (y1 > y2) {
_swap_int16_t(y2, y1); _swap_int16_t(x2, x1);
}
if (y0 > y1) {
_swap_int16_t(y0, y1); _swap_int16_t(x0, x1);
}
startWrite();
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;
writeFastHLine(a, y0, b-a+1, color);
endWrite();
return;
}
int16_t
dx01 = x1 - x0,
dy01 = y1 - y0,
dx02 = x2 - x0,
dy02 = y2 - y0,
dx12 = x2 - x1,
dy12 = y2 - y1;
int32_t
sa = 0,
sb = 0;
// For upper part of triangle, find scanline crossings for segments
// 0-1 and 0-2. If y1=y2 (flat-bottomed triangle), the scanline y1
// is included here (and second loop will be skipped, avoiding a /0
// error there), otherwise scanline y1 is skipped here and handled
// in the second loop...which also avoids a /0 error here if y0=y1
// (flat-topped triangle).
if(y1 == y2) last = y1; // Include y1 scanline
else last = y1-1; // Skip it
for(y=y0; y<=last; y++) {
a = x0 + sa / dy01;
b = x0 + sb / dy02;
sa += dx01;
sb += dx02;
/* longhand:
a = x0 + (x1 - x0) * (y - y0) / (y1 - y0);
b = x0 + (x2 - x0) * (y - y0) / (y2 - y0);
*/
if(a > b) _swap_int16_t(a,b);
writeFastHLine(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 = (int32_t)dx12 * (y - y1);
sb = (int32_t)dx02 * (y - y0);
for(; y<=y2; y++) {
a = x1 + sa / dy12;
b = x0 + sb / dy02;
sa += dx12;
sb += dx02;
/* longhand:
a = x1 + (x2 - x1) * (y - y1) / (y2 - y1);
b = x0 + (x2 - x0) * (y - y0) / (y2 - y0);
*/
if(a > b) _swap_int16_t(a,b);
writeFastHLine(a, y, b-a+1, color);
}
endWrite();
}
// BITMAP / XBITMAP / GRAYSCALE / RGB BITMAP FUNCTIONS ---------------------
/**************************************************************************/
/*!
@brief Draw a PROGMEM-resident 1-bit image at the specified (x,y) position, using the specified foreground color (unset bits are transparent).
@param x Top left corner x coordinate
@param y Top left corner y coordinate
@param bitmap byte array with monochrome bitmap
@param w Width of bitmap in pixels
@param h Height of bitmap in pixels
@param color 16-bit 5-6-5 Color to draw with
*/
/**************************************************************************/
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 byteWidth = (w + 7) / 8; // Bitmap scanline pad = whole byte
uint8_t byte = 0;
startWrite();
for(int16_t j=0; j<h; j++, y++) {
for(int16_t i=0; i<w; i++) {
if(i & 7) byte <<= 1;
else byte = pgm_read_byte(&bitmap[j * byteWidth + i / 8]);
if(byte & 0x80) writePixel(x+i, y, color);
}
}
endWrite();
}
/**************************************************************************/
/*!
@brief Draw a PROGMEM-resident 1-bit image at the specified (x,y) position, using the specified foreground (for set bits) and background (unset bits) colors.
@param x Top left corner x coordinate
@param y Top left corner y coordinate
@param bitmap byte array with monochrome bitmap
@param w Width of bitmap in pixels
@param h Height of bitmap in pixels
@param color 16-bit 5-6-5 Color to draw pixels with
@param bg 16-bit 5-6-5 Color to draw background with
*/
/**************************************************************************/
void Adafruit_GFX::drawBitmap(int16_t x, int16_t y,
const uint8_t bitmap[], int16_t w, int16_t h,
uint16_t color, uint16_t bg) {
int16_t byteWidth = (w + 7) / 8; // Bitmap scanline pad = whole byte
uint8_t byte = 0;
startWrite();
for(int16_t j=0; j<h; j++, y++) {
for(int16_t i=0; i<w; i++ ) {
if(i & 7) byte <<= 1;
else byte = pgm_read_byte(&bitmap[j * byteWidth + i / 8]);
writePixel(x+i, y, (byte & 0x80) ? color : bg);
}
}
endWrite();
}
/**************************************************************************/
/*!
@brief Draw a RAM-resident 1-bit image at the specified (x,y) position, using the specified foreground color (unset bits are transparent).
@param x Top left corner x coordinate
@param y Top left corner y coordinate
@param bitmap byte array with monochrome bitmap
@param w Width of bitmap in pixels
@param h Height of bitmap in pixels
@param color 16-bit 5-6-5 Color to draw with
*/
/**************************************************************************/
void Adafruit_GFX::drawBitmap(int16_t x, int16_t y,
uint8_t *bitmap, int16_t w, int16_t h, uint16_t color) {
int16_t byteWidth = (w + 7) / 8; // Bitmap scanline pad = whole byte
uint8_t byte = 0;
startWrite();
for(int16_t j=0; j<h; j++, y++) {
for(int16_t i=0; i<w; i++ ) {
if(i & 7) byte <<= 1;
else byte = bitmap[j * byteWidth + i / 8];
if(byte & 0x80) writePixel(x+i, y, color);
}
}
endWrite();
}
/**************************************************************************/
/*!
@brief Draw a RAM-resident 1-bit image at the specified (x,y) position, using the specified foreground (for set bits) and background (unset bits) colors.
@param x Top left corner x coordinate
@param y Top left corner y coordinate
@param bitmap byte array with monochrome bitmap
@param w Width of bitmap in pixels
@param h Height of bitmap in pixels
@param color 16-bit 5-6-5 Color to draw pixels with
@param bg 16-bit 5-6-5 Color to draw background with
*/
/**************************************************************************/
void Adafruit_GFX::drawBitmap(int16_t x, int16_t y,
uint8_t *bitmap, int16_t w, int16_t h, uint16_t color, uint16_t bg) {
int16_t byteWidth = (w + 7) / 8; // Bitmap scanline pad = whole byte
uint8_t byte = 0;
startWrite();
for(int16_t j=0; j<h; j++, y++) {
for(int16_t i=0; i<w; i++ ) {
if(i & 7) byte <<= 1;
else byte = bitmap[j * byteWidth + i / 8];
writePixel(x+i, y, (byte & 0x80) ? color : bg);
}
}
endWrite();
}
/**************************************************************************/
/*!
@brief Draw PROGMEM-resident XBitMap Files (*.xbm), exported from GIMP.
Usage: Export from GIMP to *.xbm, rename *.xbm to *.c and open in editor.
C Array can be directly used with this function.
There is no RAM-resident version of this function; if generating bitmaps
in RAM, use the format defined by drawBitmap() and call that instead.
@param x Top left corner x coordinate
@param y Top left corner y coordinate
@param bitmap byte array with monochrome bitmap
@param w Width of bitmap in pixels
@param h Height of bitmap in pixels
@param color 16-bit 5-6-5 Color to draw pixels with
*/
/**************************************************************************/
void Adafruit_GFX::drawXBitmap(int16_t x, int16_t y,
const uint8_t bitmap[], int16_t w, int16_t h, uint16_t color) {
int16_t byteWidth = (w + 7) / 8; // Bitmap scanline pad = whole byte
uint8_t byte = 0;
startWrite();
for(int16_t j=0; j<h; j++, y++) {
for(int16_t i=0; i<w; i++ ) {
if(i & 7) byte >>= 1;
else byte = pgm_read_byte(&bitmap[j * byteWidth + i / 8]);
// Nearly identical to drawBitmap(), only the bit order
// is reversed here (left-to-right = LSB to MSB):
if(byte & 0x01) writePixel(x+i, y, color);
}
}
endWrite();
}
/**************************************************************************/
/*!
@brief Draw a PROGMEM-resident 8-bit image (grayscale) at the specified (x,y) pos.
Specifically for 8-bit display devices such as IS31FL3731; no color reduction/expansion is performed.
@param x Top left corner x coordinate
@param y Top left corner y coordinate
@param bitmap byte array with grayscale bitmap
@param w Width of bitmap in pixels
@param h Height of bitmap in pixels
*/
/**************************************************************************/
void Adafruit_GFX::drawGrayscaleBitmap(int16_t x, int16_t y,
const uint8_t bitmap[], int16_t w, int16_t h) {
startWrite();
for(int16_t j=0; j<h; j++, y++) {
for(int16_t i=0; i<w; i++ ) {
writePixel(x+i, y, (uint8_t)pgm_read_byte(&bitmap[j * w + i]));
}
}
endWrite();
}
/**************************************************************************/
/*!
@brief Draw a RAM-resident 8-bit image (grayscale) at the specified (x,y) pos.
Specifically for 8-bit display devices such as IS31FL3731; no color reduction/expansion is performed.
@param x Top left corner x coordinate
@param y Top left corner y coordinate
@param bitmap byte array with grayscale bitmap
@param w Width of bitmap in pixels
@param h Height of bitmap in pixels
*/
/**************************************************************************/
void Adafruit_GFX::drawGrayscaleBitmap(int16_t x, int16_t y,
uint8_t *bitmap, int16_t w, int16_t h) {
startWrite();
for(int16_t j=0; j<h; j++, y++) {
for(int16_t i=0; i<w; i++ ) {
writePixel(x+i, y, bitmap[j * w + i]);
}
}
endWrite();
}
/**************************************************************************/
/*!
@brief Draw a PROGMEM-resident 8-bit image (grayscale) with a 1-bit mask
(set bits = opaque, unset bits = clear) at the specified (x,y) position.
BOTH buffers (grayscale and mask) must be PROGMEM-resident.
Specifically for 8-bit display devices such as IS31FL3731; no color reduction/expansion is performed.
@param x Top left corner x coordinate
@param y Top left corner y coordinate
@param bitmap byte array with grayscale bitmap
@param mask byte array with mask bitmap
@param w Width of bitmap in pixels
@param h Height of bitmap in pixels
*/
/**************************************************************************/
void Adafruit_GFX::drawGrayscaleBitmap(int16_t x, int16_t y,
const uint8_t bitmap[], const uint8_t mask[],
int16_t w, int16_t h) {
int16_t bw = (w + 7) / 8; // Bitmask scanline pad = whole byte
uint8_t byte = 0;
startWrite();
for(int16_t j=0; j<h; j++, y++) {
for(int16_t i=0; i<w; i++ ) {
if(i & 7) byte <<= 1;
else byte = pgm_read_byte(&mask[j * bw + i / 8]);
if(byte & 0x80) {
writePixel(x+i, y, (uint8_t)pgm_read_byte(&bitmap[j * w + i]));
}
}
}
endWrite();
}
/**************************************************************************/
/*!
@brief Draw a RAM-resident 8-bit image (grayscale) with a 1-bit mask
(set bits = opaque, unset bits = clear) at the specified (x,y) position.
BOTH buffers (grayscale and mask) must be RAM-residentt, no mix-and-match
Specifically for 8-bit display devices such as IS31FL3731; no color reduction/expansion is performed.
@param x Top left corner x coordinate
@param y Top left corner y coordinate
@param bitmap byte array with grayscale bitmap
@param mask byte array with mask bitmap
@param w Width of bitmap in pixels
@param h Height of bitmap in pixels
*/
/**************************************************************************/
void Adafruit_GFX::drawGrayscaleBitmap(int16_t x, int16_t y,
uint8_t *bitmap, uint8_t *mask, int16_t w, int16_t h) {
int16_t bw = (w + 7) / 8; // Bitmask scanline pad = whole byte
uint8_t byte = 0;
startWrite();
for(int16_t j=0; j<h; j++, y++) {
for(int16_t i=0; i<w; i++ ) {
if(i & 7) byte <<= 1;
else byte = mask[j * bw + i / 8];
if(byte & 0x80) {
writePixel(x+i, y, bitmap[j * w + i]);
}
}
}
endWrite();
}
/**************************************************************************/
/*!
@brief Draw a PROGMEM-resident 16-bit image (RGB 5/6/5) at the specified (x,y) position.
For 16-bit display devices; no color reduction performed.
@param x Top left corner x coordinate
@param y Top left corner y coordinate
@param bitmap byte array with 16-bit color bitmap
@param w Width of bitmap in pixels
@param h Height of bitmap in pixels
*/
/**************************************************************************/
void Adafruit_GFX::drawRGBBitmap(int16_t x, int16_t y,
const uint16_t bitmap[], int16_t w, int16_t h) {
startWrite();
for(int16_t j=0; j<h; j++, y++) {
for(int16_t i=0; i<w; i++ ) {
writePixel(x+i, y, pgm_read_word(&bitmap[j * w + i]));
}
}
endWrite();
}
/**************************************************************************/
/*!
@brief Draw a RAM-resident 16-bit image (RGB 5/6/5) at the specified (x,y) position.
For 16-bit display devices; no color reduction performed.
@param x Top left corner x coordinate
@param y Top left corner y coordinate
@param bitmap byte array with 16-bit color bitmap
@param w Width of bitmap in pixels
@param h Height of bitmap in pixels
*/
/**************************************************************************/
void Adafruit_GFX::drawRGBBitmap(int16_t x, int16_t y,
uint16_t *bitmap, int16_t w, int16_t h) {
startWrite();
for(int16_t j=0; j<h; j++, y++) {
for(int16_t i=0; i<w; i++ ) {
writePixel(x+i, y, bitmap[j * w + i]);
}
}
endWrite();
}
/**************************************************************************/
/*!
@brief Draw a PROGMEM-resident 16-bit image (RGB 5/6/5) with a 1-bit mask (set bits = opaque, unset bits = clear) at the specified (x,y) position. BOTH buffers (color and mask) must be PROGMEM-resident. For 16-bit display devices; no color reduction performed.
@param x Top left corner x coordinate
@param y Top left corner y coordinate
@param bitmap byte array with 16-bit color bitmap
@param mask byte array with monochrome mask bitmap
@param w Width of bitmap in pixels
@param h Height of bitmap in pixels
*/
/**************************************************************************/
void Adafruit_GFX::drawRGBBitmap(int16_t x, int16_t y,
const uint16_t bitmap[], const uint8_t mask[],
int16_t w, int16_t h) {
int16_t bw = (w + 7) / 8; // Bitmask scanline pad = whole byte
uint8_t byte = 0;
startWrite();
for(int16_t j=0; j<h; j++, y++) {
for(int16_t i=0; i<w; i++ ) {
if(i & 7) byte <<= 1;
else byte = pgm_read_byte(&mask[j * bw + i / 8]);
if(byte & 0x80) {
writePixel(x+i, y, pgm_read_word(&bitmap[j * w + i]));
}
}
}
endWrite();
}
/**************************************************************************/
/*!
@brief Draw a RAM-resident 16-bit image (RGB 5/6/5) with a 1-bit mask (set bits = opaque, unset bits = clear) at the specified (x,y) position. BOTH buffers (color and mask) must be RAM-resident. For 16-bit display devices; no color reduction performed.
@param x Top left corner x coordinate
@param y Top left corner y coordinate
@param bitmap byte array with 16-bit color bitmap
@param mask byte array with monochrome mask bitmap
@param w Width of bitmap in pixels
@param h Height of bitmap in pixels
*/
/**************************************************************************/
void Adafruit_GFX::drawRGBBitmap(int16_t x, int16_t y,
uint16_t *bitmap, uint8_t *mask, int16_t w, int16_t h) {
int16_t bw = (w + 7) / 8; // Bitmask scanline pad = whole byte
uint8_t byte = 0;
startWrite();
for(int16_t j=0; j<h; j++, y++) {
for(int16_t i=0; i<w; i++ ) {
if(i & 7) byte <<= 1;
else byte = mask[j * bw + i / 8];
if(byte & 0x80) {
writePixel(x+i, y, bitmap[j * w + i]);
}
}
}
endWrite();
}
// TEXT- AND CHARACTER-HANDLING FUNCTIONS ----------------------------------
// Draw a character
/**************************************************************************/
/*!
@brief Draw a single character
@param x Bottom left corner x coordinate
@param y Bottom left corner y coordinate
@param c The 8-bit font-indexed character (likely ascii)
@param color 16-bit 5-6-5 Color to draw chraracter with
@param bg 16-bit 5-6-5 Color to fill background with (if same as color, no background)
@param size Font magnification level, 1 is 'original' size
*/
/**************************************************************************/
void Adafruit_GFX::drawChar(int16_t x, int16_t y, unsigned char c,
uint16_t color, uint16_t bg, uint8_t size) {
if(!gfxFont) { // 'Classic' built-in font
if((x >= _width) || // Clip right
(y >= _height) || // Clip bottom
((x + 6 * size - 1) < 0) || // Clip left
((y + 8 * size - 1) < 0)) // Clip top
return;
if(!_cp437 && (c >= 176)) c++; // Handle 'classic' charset behavior
startWrite();
for(int8_t i=0; i<5; i++ ) { // Char bitmap = 5 columns
uint8_t line = pgm_read_byte(&font[c * 5 + i]);
for(int8_t j=0; j<8; j++, line >>= 1) {
if(line & 1) {
if(size == 1)
writePixel(x+i, y+j, color);
else
writeFillRect(x+i*size, y+j*size, size, size, color);
} else if(bg != color) {
if(size == 1)
writePixel(x+i, y+j, bg);
else
writeFillRect(x+i*size, y+j*size, size, size, bg);
}
}
}
if(bg != color) { // If opaque, draw vertical line for last column
if(size == 1) writeFastVLine(x+5, y, 8, bg);
else writeFillRect(x+5*size, y, size, 8*size, bg);
}
endWrite();
} else { // Custom font
// Character is assumed previously filtered by write() to eliminate
// newlines, returns, non-printable characters, etc. Calling
// drawChar() directly with 'bad' characters of font may cause mayhem!
c -= (uint8_t)pgm_read_byte(&gfxFont->first);
uint8_t ya = pgm_read_byte(&gfxFont->yAdvance);
GFXglyph *glyph = &(((GFXglyph *)pgm_read_pointer(&gfxFont->glyph))[c]);
uint8_t *bitmap = (uint8_t *)pgm_read_pointer(&gfxFont->bitmap);
uint16_t zz,bo = pgm_read_word(&glyph->bitmapOffset);
uint8_t w = pgm_read_byte(&glyph->width),
h = pgm_read_byte(&glyph->height),
xa = pgm_read_byte(&glyph->xAdvance);
int8_t xo = pgm_read_byte(&glyph->xOffset),
yo = pgm_read_byte(&glyph->yOffset);
uint8_t xx, yy, bits = 0, bit = 0;
int16_t xo16 = 0, yo16 = 0;
if(size > 1) {
xo16 = xo;
yo16 = yo;
}
// Todo: Add character clipping here
// NOTE: THERE IS NO 'BACKGROUND' COLOR OPTION ON CUSTOM FONTS.
// THIS IS ON PURPOSE AND BY DESIGN. The background color feature
// has typically been used with the 'classic' font to overwrite old
// screen contents with new data. This ONLY works because the
// characters are a uniform size; it's not a sensible thing to do with
// proportionally-spaced fonts with glyphs of varying sizes (and that
// may overlap). To replace previously-drawn text when using a custom
// font, use the getTextBounds() function to determine the smallest
// rectangle encompassing a string, erase the area with fillRect(),
// then draw new text. This WILL infortunately 'blink' the text, but
// is unavoidable. Drawing 'background' pixels will NOT fix this,
// only creates a new set of problems. Have an idea to work around
// this (a canvas object type for MCUs that can afford the RAM and
// displays supporting setAddrWindow() and pushColors()), but haven't
// implemented this yet.
startWrite();
for(yy=0; yy<ya; yy++) {
for(xx=0; xx<xa; xx++) {
zz = bg;
if ((yy>=(30+yo))&&(yy<(30+yo+h))&&(xx>=xo)&&(xx<(xo+w))) {
if(!(bit++ & 7)) {
bits = pgm_read_byte(&bitmap[bo++]);
}
if(bits & 0x80) {
zz = color;
}
bits <<= 1;
}
writePixel(x+xx, y-30+yy, zz);
}
}
endWrite();
} // End classic vs custom font
}
/**************************************************************************/
/*!
@brief Print one byte/character of data, used to support print()
@param c The 8-bit ascii character to write
*/
/**************************************************************************/
size_t Adafruit_GFX::write(uint8_t c) {
if(!gfxFont) { // 'Classic' built-in font
if(c == '\n') { // Newline?
cursor_x = 0; // Reset x to zero,
cursor_y += textsize * 8; // advance y one line
} else if(c != '\r') { // Ignore carriage returns
if(wrap && ((cursor_x + textsize * 6) > _width)) { // Off right?
cursor_x = 0; // Reset x to zero,
cursor_y += textsize * 8; // advance y one line
}
drawChar(cursor_x, cursor_y, c, textcolor, textbgcolor, textsize);
cursor_x += textsize * 6; // Advance x one char
}
} else { // Custom font
if(c == '\n') {
cursor_x = 0;
cursor_y += (int16_t)textsize *
(uint8_t)pgm_read_byte(&gfxFont->yAdvance);
} else if(c != '\r') {
uint8_t first = pgm_read_byte(&gfxFont->first);
if((c >= first) && (c <= (uint8_t)pgm_read_byte(&gfxFont->last))) {
GFXglyph *glyph = &(((GFXglyph *)pgm_read_pointer(
&gfxFont->glyph))[c - first]);
uint8_t w = pgm_read_byte(&glyph->width),
h = pgm_read_byte(&glyph->height);
if((w > 0) && (h > 0)) { // Is there an associated bitmap?
int16_t xo = (int8_t)pgm_read_byte(&glyph->xOffset); // sic
if(wrap && ((cursor_x + textsize * (xo + w)) > _width)) {
cursor_x = 0;
cursor_y += (int16_t)textsize *
(uint8_t)pgm_read_byte(&gfxFont->yAdvance);
}
drawChar(cursor_x, cursor_y, c, textcolor, textbgcolor, textsize);
}
cursor_x += (uint8_t)pgm_read_byte(&glyph->xAdvance) * (int16_t)textsize;
}
}
}
return 1;
}
/**************************************************************************/
/*!
@brief Set text 'magnification' size. Each increase in s makes 1 pixel that much bigger.
@param s Desired text size. 1 is default 6x8, 2 is 12x16, 3 is 18x24, etc
*/
/**************************************************************************/
void Adafruit_GFX::setTextSize(uint8_t s) {
textsize = (s > 0) ? s : 1;
}
/**************************************************************************/
/*!
@brief Set rotation setting for display
@param x 0 thru 3 corresponding to 4 cardinal rotations
*/
/**************************************************************************/
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;
}
}
/**************************************************************************/
/*!
@brief Set the font to display when print()ing, either custom or default
@param f The GFXfont object, if NULL use built in 6x8 font
*/
/**************************************************************************/
void Adafruit_GFX::setFont(const GFXfont *f) {
if(f) { // Font struct pointer passed in?
if(!gfxFont) { // And no current font struct?
// Switching from classic to new font behavior.
// Move cursor pos down 6 pixels so it's on baseline.
cursor_y += 6;
}
} else if(gfxFont) { // NULL passed. Current font struct defined?
// Switching from new to classic font behavior.
// Move cursor pos up 6 pixels so it's at top-left of char.
cursor_y -= 6;
}
gfxFont = (GFXfont *)f;
}
/**************************************************************************/
/*!
@brief Helper to determine size of a character with current font/size.
Broke this out as it's used by both the PROGMEM- and RAM-resident getTextBounds() functions.
@param c The ascii character in question
@param x Pointer to x location of character
@param y Pointer to y location of character
@param minx Minimum clipping value for X
@param miny Minimum clipping value for Y
@param maxx Maximum clipping value for X
@param maxy Maximum clipping value for Y
*/
/**************************************************************************/
void Adafruit_GFX::charBounds(char c, int16_t *x, int16_t *y,
int16_t *minx, int16_t *miny, int16_t *maxx, int16_t *maxy) {
if(gfxFont) {
if(c == '\n') { // Newline?
*x = 0; // Reset x to zero, advance y by one line
*y += textsize * (uint8_t)pgm_read_byte(&gfxFont->yAdvance);
} else if(c != '\r') { // Not a carriage return; is normal char
uint8_t first = pgm_read_byte(&gfxFont->first),
last = pgm_read_byte(&gfxFont->last);
if((c >= first) && (c <= last)) { // Char present in this font?
GFXglyph *glyph = &(((GFXglyph *)pgm_read_pointer(
&gfxFont->glyph))[c - first]);
uint8_t gw = pgm_read_byte(&glyph->width),
gh = pgm_read_byte(&glyph->height),
xa = pgm_read_byte(&glyph->xAdvance);
int8_t xo = pgm_read_byte(&glyph->xOffset),
yo = pgm_read_byte(&glyph->yOffset);
if(wrap && ((*x+(((int16_t)xo+gw)*textsize)) > _width)) {
*x = 0; // Reset x to zero, advance y by one line
*y += textsize * (uint8_t)pgm_read_byte(&gfxFont->yAdvance);
}
int16_t ts = (int16_t)textsize,
x1 = *x + xo * ts,
y1 = *y + yo * ts,
x2 = x1 + gw * ts - 1,
y2 = y1 + gh * ts - 1;
if(x1 < *minx) *minx = x1;
if(y1 < *miny) *miny = y1;
if(x2 > *maxx) *maxx = x2;
if(y2 > *maxy) *maxy = y2;
*x += xa * ts;
}
}
} else { // Default font
if(c == '\n') { // Newline?
*x = 0; // Reset x to zero,
*y += textsize * 8; // advance y one line
// min/max x/y unchaged -- that waits for next 'normal' character
} else if(c != '\r') { // Normal char; ignore carriage returns
if(wrap && ((*x + textsize * 6) > _width)) { // Off right?
*x = 0; // Reset x to zero,
*y += textsize * 8; // advance y one line
}
int x2 = *x + textsize * 6 - 1, // Lower-right pixel of char
y2 = *y + textsize * 8 - 1;
if(x2 > *maxx) *maxx = x2; // Track max x, y
if(y2 > *maxy) *maxy = y2;
if(*x < *minx) *minx = *x; // Track min x, y
if(*y < *miny) *miny = *y;
*x += textsize * 6; // Advance x one char
}
}
}
/**************************************************************************/
/*!
@brief Helper to determine size of a string with current font/size. Pass string and a cursor position, returns UL corner and W,H.
@param str The ascii string to measure
@param x The current cursor X
@param y The current cursor Y
@param x1 The boundary X coordinate, set by function
@param y1 The boundary Y coordinate, set by function
@param w The boundary width, set by function
@param h The boundary height, set by function
*/
/**************************************************************************/
void Adafruit_GFX::getTextBounds(const char *str, int16_t x, int16_t y,
int16_t *x1, int16_t *y1, uint16_t *w, uint16_t *h) {
uint8_t c; // Current character
*x1 = x;
*y1 = y;
*w = *h = 0;
int16_t minx = _width, miny = _height, maxx = -1, maxy = -1;
while((c = *str++))
charBounds(c, &x, &y, &minx, &miny, &maxx, &maxy);
if(maxx >= minx) {
*x1 = minx;
*w = maxx - minx + 1;
}
if(maxy >= miny) {
*y1 = miny;
*h = maxy - miny + 1;
}
}
/**************************************************************************/
/*!
@brief Helper to determine size of a string with current font/size. Pass string and a cursor position, returns UL corner and W,H.
@param str The ascii string to measure (as an arduino String() class)
@param x The current cursor X
@param y The current cursor Y
@param x1 The boundary X coordinate, set by function
@param y1 The boundary Y coordinate, set by function
@param w The boundary width, set by function
@param h The boundary height, set by function
*/
/**************************************************************************/
void Adafruit_GFX::getTextBounds(const String &str, int16_t x, int16_t y,
int16_t *x1, int16_t *y1, uint16_t *w, uint16_t *h) {
if (str.length() != 0) {
getTextBounds(const_cast<char*>(str.c_str()), x, y, x1, y1, w, h);
}
}
/**************************************************************************/
/*!
@brief Helper to determine size of a PROGMEM string with current font/size. Pass string and a cursor position, returns UL corner and W,H.
@param str The flash-memory ascii string to measure
@param x The current cursor X
@param y The current cursor Y
@param x1 The boundary X coordinate, set by function
@param y1 The boundary Y coordinate, set by function
@param w The boundary width, set by function
@param h The boundary height, set by function
*/
/**************************************************************************/
void Adafruit_GFX::getTextBounds(const __FlashStringHelper *str,
int16_t x, int16_t y, int16_t *x1, int16_t *y1, uint16_t *w, uint16_t *h) {
uint8_t *s = (uint8_t *)str, c;
*x1 = x;
*y1 = y;
*w = *h = 0;
int16_t minx = _width, miny = _height, maxx = -1, maxy = -1;
while((c = pgm_read_byte(s++)))
charBounds(c, &x, &y, &minx, &miny, &maxx, &maxy);
if(maxx >= minx) {
*x1 = minx;
*w = maxx - minx + 1;
}
if(maxy >= miny) {
*y1 = miny;
*h = maxy - miny + 1;
}
}
/**************************************************************************/
/*!
@brief Invert the display (ideally using built-in hardware command)
@param i True if you want to invert, false to make 'normal'
*/
/**************************************************************************/
void Adafruit_GFX::invertDisplay(boolean i) {
// Do nothing, must be subclassed if supported by hardware
}
/***************************************************************************/
/**************************************************************************/
/*!
@brief Create a simple drawn button UI element
*/
/**************************************************************************/
Adafruit_GFX_Button::Adafruit_GFX_Button(void) {
_gfx = 0;
}
/**************************************************************************/
/*!
@brief Initialize button with our desired color/size/settings
@param gfx Pointer to our display so we can draw to it!
@param x The X coordinate of the center of the button
@param y The Y coordinate of the center of the button
@param w Width of the buttton
@param h Height of the buttton
@param outline Color of the outline (16-bit 5-6-5 standard)
@param fill Color of the button fill (16-bit 5-6-5 standard)
@param textcolor Color of the button label (16-bit 5-6-5 standard)
@param label Ascii string of the text inside the button
@param textsize The font magnification of the label text
*/
/**************************************************************************/
// Classic initButton() function: pass center & size
void Adafruit_GFX_Button::initButton(
Adafruit_GFX *gfx, int16_t x, int16_t y, uint16_t w, uint16_t h,
uint16_t outline, uint16_t fill, uint16_t textcolor,
char *label, uint8_t textsize)
{
// Tweak arguments and pass to the newer initButtonUL() function...
initButtonUL(gfx, x - (w / 2), y - (h / 2), w, h, outline, fill,
textcolor, label, textsize);
}
/**************************************************************************/
/*!
@brief Initialize button with our desired color/size/settings, with upper-left coordinates
@param gfx Pointer to our display so we can draw to it!
@param x1 The X coordinate of the Upper-Left corner of the button
@param y1 The Y coordinate of the Upper-Left corner of the button
@param w Width of the buttton
@param h Height of the buttton
@param outline Color of the outline (16-bit 5-6-5 standard)
@param fill Color of the button fill (16-bit 5-6-5 standard)
@param textcolor Color of the button label (16-bit 5-6-5 standard)
@param label Ascii string of the text inside the button
@param textsize The font magnification of the label text
*/
/**************************************************************************/
void Adafruit_GFX_Button::initButtonUL(
Adafruit_GFX *gfx, int16_t x1, int16_t y1, uint16_t w, uint16_t h,
uint16_t outline, uint16_t fill, uint16_t textcolor,
char *label, uint8_t textsize)
{
_x1 = x1;
_y1 = y1;
_w = w;
_h = h;
_outlinecolor = outline;
_fillcolor = fill;
_textcolor = textcolor;
_textsize = textsize;
_gfx = gfx;
strncpy(_label, label, 9);
}
/**************************************************************************/
/*!
@brief Draw the button on the screen
@param inverted Whether to draw with fill/text swapped to indicate 'pressed'
*/
/**************************************************************************/
void Adafruit_GFX_Button::drawButton(boolean inverted) {
uint16_t fill, outline, text;
if(!inverted) {
fill = _fillcolor;
outline = _outlinecolor;
text = _textcolor;
} else {
fill = _textcolor;
outline = _outlinecolor;
text = _fillcolor;
}
uint8_t r = min(_w, _h) / 4; // Corner radius
_gfx->fillRoundRect(_x1, _y1, _w, _h, r, fill);
_gfx->drawRoundRect(_x1, _y1, _w, _h, r, outline);
_gfx->setCursor(_x1 + (_w/2) - (strlen(_label) * 3 * _textsize),
_y1 + (_h/2) - (4 * _textsize));
_gfx->setTextColor(text);
_gfx->setTextSize(_textsize);
_gfx->print(_label);
}
/**************************************************************************/
/*!
@brief Helper to let us know if a coordinate is within the bounds of the button
@param x The X coordinate to check
@param y The Y coordinate to check
@returns True if within button graphics outline
*/
/**************************************************************************/
boolean Adafruit_GFX_Button::contains(int16_t x, int16_t y) {
return ((x >= _x1) && (x < (int16_t) (_x1 + _w)) &&
(y >= _y1) && (y < (int16_t) (_y1 + _h)));
}
/**************************************************************************/
/*!
@brief Query whether the button was pressed since we last checked state
@returns True if was not-pressed before, now is.
*/
/**************************************************************************/
boolean Adafruit_GFX_Button::justPressed() { return (currstate && !laststate); }
/**************************************************************************/
/*!
@brief Query whether the button was released since we last checked state
@returns True if was pressed before, now is not.
*/
/**************************************************************************/
boolean Adafruit_GFX_Button::justReleased() { return (!currstate && laststate); }
// -------------------------------------------------------------------------
// GFXcanvas1, GFXcanvas8 and GFXcanvas16 (currently a WIP, don't get too
// comfy with the implementation) provide 1-, 8- and 16-bit offscreen
// canvases, the address of which can be passed to drawBitmap() or
// pushColors() (the latter appears only in a couple of GFX-subclassed TFT
// libraries at this time). This is here mostly to help with the recently-
// added proportionally-spaced fonts; adds a way to refresh a section of the
// screen without a massive flickering clear-and-redraw...but maybe you'll
// find other uses too. VERY RAM-intensive, since the buffer is in MCU
// memory and not the display driver...GXFcanvas1 might be minimally useful
// on an Uno-class board, but this and the others are much more likely to
// require at least a Mega or various recent ARM-type boards (recommended,
// as the text+bitmap draw can be pokey). GFXcanvas1 requires 1 bit per
// pixel (rounded up to nearest byte per scanline), GFXcanvas8 is 1 byte
// per pixel (no scanline pad), and GFXcanvas16 uses 2 bytes per pixel (no
// scanline pad).
// NOT EXTENSIVELY TESTED YET. MAY CONTAIN WORST BUGS KNOWN TO HUMANKIND.
/**************************************************************************/
/*!
@brief Instatiate a GFX 1-bit canvas context for graphics
@param w Display width, in pixels
@param h Display height, in pixels
*/
/**************************************************************************/
GFXcanvas1::GFXcanvas1(uint16_t w, uint16_t h) : Adafruit_GFX(w, h) {
uint16_t bytes = ((w + 7) / 8) * h;
if((buffer = (uint8_t *)malloc(bytes))) {
memset(buffer, 0, bytes);
}
}
/**************************************************************************/
/*!
@brief Delete the canvas, free memory
*/
/**************************************************************************/
GFXcanvas1::~GFXcanvas1(void) {
if(buffer) free(buffer);
}
/**************************************************************************/
/*!
@brief Draw a pixel to the canvas framebuffer
@param x x coordinate
@param y y coordinate
@param color 16-bit 5-6-5 Color to fill with
*/
/**************************************************************************/
void GFXcanvas1::drawPixel(int16_t x, int16_t y, uint16_t color) {
#ifdef __AVR__
// Bitmask tables of 0x80>>X and ~(0x80>>X), because X>>Y is slow on AVR
static const uint8_t PROGMEM
GFXsetBit[] = { 0x80, 0x40, 0x20, 0x10, 0x08, 0x04, 0x02, 0x01 },
GFXclrBit[] = { 0x7F, 0xBF, 0xDF, 0xEF, 0xF7, 0xFB, 0xFD, 0xFE };
#endif
if(buffer) {
if((x < 0) || (y < 0) || (x >= _width) || (y >= _height)) return;
int16_t t;
switch(rotation) {
case 1:
t = x;
x = WIDTH - 1 - y;
y = t;
break;
case 2:
x = WIDTH - 1 - x;
y = HEIGHT - 1 - y;
break;
case 3:
t = x;
x = y;
y = HEIGHT - 1 - t;
break;
}
uint8_t *ptr = &buffer[(x / 8) + y * ((WIDTH + 7) / 8)];
#ifdef __AVR__
if(color) *ptr |= pgm_read_byte(&GFXsetBit[x & 7]);
else *ptr &= pgm_read_byte(&GFXclrBit[x & 7]);
#else
if(color) *ptr |= 0x80 >> (x & 7);
else *ptr &= ~(0x80 >> (x & 7));
#endif
}
}
/**************************************************************************/
/*!
@brief Fill the framebuffer completely with one color
@param color 16-bit 5-6-5 Color to fill with
*/
/**************************************************************************/
void GFXcanvas1::fillScreen(uint16_t color) {
if(buffer) {
uint16_t bytes = ((WIDTH + 7) / 8) * HEIGHT;
memset(buffer, color ? 0xFF : 0x00, bytes);
}
}
/**************************************************************************/
/*!
@brief Instatiate a GFX 8-bit canvas context for graphics
@param w Display width, in pixels
@param h Display height, in pixels
*/
/**************************************************************************/
GFXcanvas8::GFXcanvas8(uint16_t w, uint16_t h) : Adafruit_GFX(w, h) {
uint32_t bytes = w * h;
if((buffer = (uint8_t *)malloc(bytes))) {
memset(buffer, 0, bytes);
}
}
/**************************************************************************/
/*!
@brief Delete the canvas, free memory
*/
/**************************************************************************/
GFXcanvas8::~GFXcanvas8(void) {
if(buffer) free(buffer);
}
/**************************************************************************/
/*!
@brief Draw a pixel to the canvas framebuffer
@param x x coordinate
@param y y coordinate
@param color 16-bit 5-6-5 Color to fill with
*/
/**************************************************************************/
void GFXcanvas8::drawPixel(int16_t x, int16_t y, uint16_t color) {
if(buffer) {
if((x < 0) || (y < 0) || (x >= _width) || (y >= _height)) return;
int16_t t;
switch(rotation) {
case 1:
t = x;
x = WIDTH - 1 - y;
y = t;
break;
case 2:
x = WIDTH - 1 - x;
y = HEIGHT - 1 - y;
break;
case 3:
t = x;
x = y;
y = HEIGHT - 1 - t;
break;
}
buffer[x + y * WIDTH] = color;
}
}
/**************************************************************************/
/*!
@brief Fill the framebuffer completely with one color
@param color 16-bit 5-6-5 Color to fill with
*/
/**************************************************************************/
void GFXcanvas8::fillScreen(uint16_t color) {
if(buffer) {
memset(buffer, color, WIDTH * HEIGHT);
}
}
void GFXcanvas8::writeFastHLine(int16_t x, int16_t y,
int16_t w, uint16_t color) {
if((x >= _width) || (y < 0) || (y >= _height)) return;
int16_t x2 = x + w - 1;
if(x2 < 0) return;
// Clip left/right
if(x < 0) {
x = 0;
w = x2 + 1;
}
if(x2 >= _width) w = _width - x;
int16_t t;
switch(rotation) {
case 1:
t = x;
x = WIDTH - 1 - y;
y = t;
break;
case 2:
x = WIDTH - 1 - x;
y = HEIGHT - 1 - y;
break;
case 3:
t = x;
x = y;
y = HEIGHT - 1 - t;
break;
}
memset(buffer + y * WIDTH + x, color, w);
}
/**************************************************************************/
/*!
@brief Instatiate a GFX 16-bit canvas context for graphics
@param w Display width, in pixels
@param h Display height, in pixels
*/
/**************************************************************************/
GFXcanvas16::GFXcanvas16(uint16_t w, uint16_t h) : Adafruit_GFX(w, h) {
uint32_t bytes = w * h * 2;
if((buffer = (uint16_t *)malloc(bytes))) {
memset(buffer, 0, bytes);
}
}
/**************************************************************************/
/*!
@brief Delete the canvas, free memory
*/
/**************************************************************************/
GFXcanvas16::~GFXcanvas16(void) {
if(buffer) free(buffer);
}
/**************************************************************************/
/*!
@brief Draw a pixel to the canvas framebuffer
@param x x coordinate
@param y y coordinate
@param color 16-bit 5-6-5 Color to fill with
*/
/**************************************************************************/
void GFXcanvas16::drawPixel(int16_t x, int16_t y, uint16_t color) {
if(buffer) {
if((x < 0) || (y < 0) || (x >= _width) || (y >= _height)) return;
int16_t t;
switch(rotation) {
case 1:
t = x;
x = WIDTH - 1 - y;
y = t;
break;
case 2:
x = WIDTH - 1 - x;
y = HEIGHT - 1 - y;
break;
case 3:
t = x;
x = y;
y = HEIGHT - 1 - t;
break;
}
buffer[x + y * WIDTH] = color;
}
}
/**************************************************************************/
/*!
@brief Fill the framebuffer completely with one color
@param color 16-bit 5-6-5 Color to fill with
*/
/**************************************************************************/
void GFXcanvas16::fillScreen(uint16_t color) {
if(buffer) {
uint8_t hi = color >> 8, lo = color & 0xFF;
if(hi == lo) {
memset(buffer, lo, WIDTH * HEIGHT * 2);
} else {
uint32_t i, pixels = WIDTH * HEIGHT;
for(i=0; i<pixels; i++) buffer[i] = color;
}
}
}
/**************************************************************************/
/*!
@brief Reverses the "endian-ness" of each 16-bit pixel within the
canvas; little-endian to big-endian, or big-endian to little.
Most microcontrollers (such as SAMD) are little-endian, while
most displays tend toward big-endianness. All the drawing
functions (including RGB bitmap drawing) take care of this
automatically, but some specialized code (usually involving
DMA) can benefit from having pixel data already in the
display-native order. Note that this does NOT convert to a
SPECIFIC endian-ness, it just flips the bytes within each word.
*/
/**************************************************************************/
void GFXcanvas16::byteSwap(void) {
if(buffer) {
uint32_t i, pixels = WIDTH * HEIGHT;
for(i=0; i<pixels; i++) buffer[i] = __builtin_bswap16(buffer[i]);
}
}
блин ты убийца библиотек:). все работает и затирает. с этим покончино. проблема следующая инфа выводится примерно через 2-3 секунды. Блин я с вас двоих поражаюсь, головы у вас золотые...
блин ты убийца библиотек:). все работает и затирает. с этим покончино. проблема следующая инфа выводится примерно через 2-3 секунды. Блин я с вас двоих поражаюсь, головы у вас золотые...
пошел пробовать.... капец, ноут батарея не держит свет вырубился. скетч был не сохранен, все долгие правки коту под хвост, но испытать успел. обновляется быстрее. с 3 секунд до 2 стало. есть косяки , может отображать то пару одних температур, обновишь страницу или перейдешь с другой может показать пару других температур. тоесть все температуры одновременно не отображает, еще заметил еще вчера что, на второй и третей странице инфы нету, не отображает, и еще раньше на моем скетче старом, при переходе или первом старте шла прописовка по строкам, строка, строка, строка и готова, а сейчас он прорисовывает какбы по буквам а не по целым строкам. фруктовая библиотека это сполошной кошмар, никогда больше экраны на этой библе брать не буду, только УТФТ. Все ну на фиг, на сегодня все. завтра заново подправлю все и еще раз буду видеть, на счет if понял
мигать на экране перестало это полбеды решено. Нужно вывести Serial.println(millis()) в начале и в конце периодической печати параметров на экран и узнаешь сколько по времени эта печать на экран занимает. Скорее всего время печати то не сильно сократилось и осталось всё равно долгим, поэтому такие редкие запросы на ЭБУ.
Надо и вывод в сериал сделать отключаемым/подключаемым при компиляции. Весь вывод на экран идёт по одной точке за раз, хоть с морганием хоть без. Стирание при моргании то же идёт по одной точке за раз, так как стирается не весь экран. Весь экран стирается блоковой командой.
Весь вывод на экран идёт по одной точке за раз, хоть с морганием хоть без. Стирание при моргании то же идёт по одной точке за раз, так как стирается не весь экран. Весь экран стирается блоковой командой.
ниче не понял если чесно. Нужно попробовать ещё использовать вместо UTFTGLUE библиотеку , которая идёт с mcu_friend типа MCUFRIEND_kbv tft; если и с ней будет тормозить , экран на помойку.
Командир отчитываюсь. Сделал все по твоей инструкции, результат 1.5 секунды обновление, что уже в два раза лучше чем было. Есть косяк, если перешел на другую страницу а потом вернулся на первкую то не все температуры есть, когда какя-то температура поменялась она появляется на экране. тоесть, не выводит на экран пока не поменяется, так все данные, не странице 2 и 3 таже фигня, не поменялась не видно, поменялась появляется. вот скетч
#include <Adafruit_GFX.h>
#include <MCUFRIEND_kbv.h>
#include <UTFTGLUE.h>//use GLUE class and constructor
#include "TouchScreen.h"
#include <stdint.h>
#include <SPI.h>
#include <EEPROM.h>
//MCUFRIEND_kbv tft;
#include "Fonts/Chosence_Bold16pt7b.h";
#define MINPRESSURE 200
#define MAXPRESSURE 1000
//pin 20 SCL , 21 SDA датчик реального времени
#include <Wire.h>
#include "RTClib.h"
RTC_DS3231 rtc;
UTFTGLUE myGLCD(0x1581,A2,A1,A3,A4,A0); //all dummy args
const int XP = 6, XM = A2, YP = A1, YM = 7;
const int TS_LEFT = 136, TS_RT = 907, TS_TOP = 139, TS_BOT = 942;
TouchScreen ts = TouchScreen(XP, YP, XM, YM, 300);
uint16_t ID;
int x, y;
char currentPage;
float h; int h_last = 1;
float t; int t_last = 1;
bool Dvoet = 0;
bool reNew = 0;
#define BLACK 0x0000
#define WHITE 0xFFFF
#define RED 0xF800
#define GREEN 0x07E0
#include <SoftwareSerial.h>
#define TX_PCM 13
SoftwareSerial K_LINE_PCM (12, TX_PCM); //RХ,TХ
#define PCM_address 0x11 // адрес PCM
#define DIAG_address 0xF1 // адрес диагностики
#define debugPCM // раскоментировать эту строку для отладки в Serial порту обмена с PCM
//#define debugGAUGE // раскоментировать эту строку для отладки в Serial порту обмена co щитком приборов
uint32_t curmillis = 0; // снимок текущего времени
uint32_t prevRequest = 0; // таймер периодических запосов на PCM
uint16_t RequestPeriod = 3500; // периодичность запросов на PCM
uint32_t prevRESETheader=0; // таймер сброса сообщения, если данные оборвались посередине сообщения
bool RESETheader_timer; // таймер сброса сообщения, если данные оборвались посередине сообщения
uint32_t prev_NOanswer=0; // таймер контроля неответов от ЭБУ после подачи запросов
bool NOanswer_timer = 0; // таймер контроля неответов от ЭБУ после подачи запросов
byte noanswers = 0; // количество подряд неответов от ЭБУ
uint32_t timerdelay = 0; // таймер ожидания байт (для успевания появления данных в буфере UART)
bool Delay = 0; // таймер ожидания байт (для успевания появления данных в буфере UART)
byte waitbyte_RX = 1; // задержка, мс для успевания появления данных в буфере RX
// (подрегулировать в зависимости от уровня жизнидеятельности на Марсе)
#define TIMER_DELAY Delay = 0; timerdelay = curmillis // включение этого таймера
byte delaybyte_TX = 1; // задержка между отправкой байт в запросах, мс
byte header = 0; // состояние заголовка
byte message_size = 0; // размер тела сообщения
byte j = 3; // инкремент
byte n = 3; // количество старт байт
const byte bufsize = 150; // размер буфера принятого сообщения
byte MessageRx_PCM [bufsize] = {0}; // буфер принятого сообщения
byte crc =0; // байт контрольной суммы
// возможные варианты запросов на ЭБУ:
enum REQUEST {
INIT,
PID,
DTCERASE,
DTCREAD,
PRESENT,
};
// текстовки запросов для отладки
char* textRequest[] = {
"INIT",
"PID_2101",
"DTC_ERASE",
"DTC_READ",
"PRESENT",
} ;
// сами запросы
byte PCM_Message_TX[][5] = {
{1, 0x81, 0,0,0}, // запрос инициализации
{2, 0x21,0x01, 0,0}, // запрос пид 2101
{3, 0x14,0xFF,0x00, 0}, // запрос на стирание ошибок
{4, 0x18,0x00,0xFF,0x00 }, // запрос на чтение ошибок
{1, 0x3E, 0,0,0}, // запрос присутствия
};
byte request = INIT; // переменная, показывающая какой запрос будем делать
//-------------------------------------------переменные бортовика
float L100M = 0; int L100M_last = 1; //расход на 100 км измеренный за поездку
float L100 = 0; int L100_last = 1; //мгновенный расход литров на 100км
float LHor = 0; int LHor_last = 1; //мгновенный расход топлива литров в час
float L100SR = 0; //расход литров на 100км измеренный раз в интервал kmL
float L100SR_TFT = 0; int L100SR_TFT_last = 1; // самый средний из расходов на 100км, он выводится на экран
int L100_Eeprom[11]= {10,10,10,10,10,10,10,10,10,10,10};
int FuelZamer[10]= {0}; // массив для измерения уровня (количества) топлива
int ZamerNumber = 0; // номер замера уровня (количества) топлива
int n_eeprom = 0; // текущий адрес ячейки еепром для записи расхода
int MAF = 0; int MAF_last = 1; //26,27 байты Sensor de flujo de aire en masa
float BoostPres = 0; int BoostPres_last = 1; //28,29 байты Presión de refuerzo
int RPM = 0; int RPM_last = 1; //32,33 байты Velocidad del motor
int EGRmg = 0; int EGRmg_last = 1; //34,35 байты Comando EGR (Comando de recirculación de gases de escape)
float BoostPresCom = 0; int BoostPresCom_last = 1; //38,39 байты Comando de presión de refuerzo
int Speed = 0; int Speed_last = 1; //44,45 байты Velocidad del vehículo
float DesaInjQua = 0; int DesaInjQua_last = 1; //50,51 байты Cantidad de inyección deseada
float InjQua = 0; int InjQua_last = 1; //52,53 байты Cantidad de la inyección
float StaDaliv = 0; int StaDaliv_last = 1; //54,55 байты Inicio de la entrega
int PumpRPM = 0; int PumpRPM_last = 1; //56,57 байты Velocidad de la bomba
float EGRPul = 0; int EGRPul_last = 1; //62,63 байты Relación de impulsos EGR (recirculación de gases de escape
float SolenPul = 0; int SolenPul_last = 1; //64,65 байты Velocidad de solenoide de control de nivel de remolino Relación de impulsos
float SolenPre = 0; int SolenPre_last = 1; //70,71 байты Relación de impulsos Presión Electroválvula de presión
float DesInj = 0; int DesInj_last = 1; //72,73 байты Inyección deseada Inicio
float ActInj = 0; int ActInj_last = 1; //16,17 байты Inicio de la inyección real
int TempAir = 0; int TempAir_last = 1; //74,75 байты Temperatura del aire de admisión
int Temp = 0; int Temp_last = 1; //14,15 байты Temperatura del refrigerante
int TempOil = 0; int TempOil_last = 1; //18,19 байты Temperatura del aceite del motor
int TempFuel = 0; int TempFuel_last = 1; //58,59 байты Temperatura del combustible
//все что касается топлива
float Fuel = 0; //остаток топлива
float Fuel2 = 0; int Fuel2_last = 1; //остаток мгновенного топлива байт 16 , датчика в баке
int FuelIGN = 0; // количество топлвива в баке на момент включения зажигания
int Fuel_last = 0; // для формул
bool flagFuelIGN = 0; // флаг записан ли остаток топлива в момент вкл. зажигания
float FuelTrip = 0; int FuelTrip_last = 1; // количество литров топлива, израсходованное за один цикл включения зажигания
//все что касается километража
float kmAge = 0; //пробег, полученный со щитка приборов
int kmAgeIGN = 0; //пробег который был в момент включения зажигания
int kmAge_last = 0; // для формул
bool flagkmAgeIGN = 0; //флаг записан ли пробег в момент вкл. зажигания
float kmTrip = 0; int kmTrip_last = 1; //пробег за один цикл включения зажигания
int kmL = 10; // интервал, через который будет происходить обновление среднего расхода на 100км
int km = 0; // переменная для расчетов
int kmeeprom = 10; // интервал, через который будет происходить подсчет среднеарифмитического расхода L100SR_TFT
int kmTFT = 0; // переменная для расчетов периодического подсчета среднеарифмитического расхода топлива L100SR_TFT
int kmREFUELING = 0; int kmREFUELING_last = 1; // пробег до заправки на остатке топлива
unsigned long prevWatch = 0;
unsigned long prevDvoet = 0;
unsigned long prevData = 0;
void setup() {
uint16_t ID = myGLCD.readID();
if (ID == 0xD3D3) ID = 0x1581; // write-only shield
myGLCD.begin(ID);
myGLCD.InitLCD(3);
myGLCD.clrScr();
myGLCD.setFont(&Chosence_Bold16pt7b);
//myGLCD.fillScreen(WHITE);
//myGLCD.setTextColor(WHITE, BLACK);
//myGLCD.setBackColor(BLACK);
Wire.begin();
rtc.begin();
//загрузка стартовой страницы
currentPage = '0';
drawHomeScreen();
//подсчет среднеарифметического усредненного расхода
for (int i = 0; i < 11; i++) L100_Eeprom [i]= EEPROM.read(i);
for (int i = 0; i < 11; i++) L100SR_TFT = L100SR_TFT + L100_Eeprom [i];
L100SR_TFT = (float)L100SR_TFT/110.0;
if (L100SR_TFT<0) L100SR_TFT = 0;
if (L100SR_TFT>99) L100SR_TFT = 99;
// строка ниже используется для настройки даты и времени часов
// раскоментировать, выставить времая и дату, залить в ардуино. в скетче закоментировать
// обратно и залить еще раз, иначе каждый раз будет по новой выствлятся это же время и дата
// (год, месяц, день, часы, минуты, секунды)
//rtc.adjust(DateTime(2017, 7, 21, 13, 57, 0));
#if defined debugPCM or debugGAUGE
Serial.begin(115200);
#endif
K_LINE_PCM.begin(10400);
pinMode(TX_PCM, OUTPUT);
}
void loop()
{
curmillis = millis(); // снимок текущего времени
if (curmillis - prevRequest > RequestPeriod && header == 0 )
{
if (request == INIT) fastinit(); // при необходимости делаем переподключение к PCM
else {sendMessagePCM(request); // отправляем на PCM текущий запрос
if (request == PID) RequestPeriod = 600;
if (request == DTCERASE || request == DTCREAD) RequestPeriod = 2500;}
prevRequest = curmillis;
}
receivePCM (); // приём сообщений от PCM
if (header == 0) Menu ();
if (curmillis - prevWatch > 3000) { Watch (); prevWatch = curmillis;}
//if (curmillis - prevDvoet > 500) { if (!Dvoet) {myGLCD.setTextColor(WHITE); } else {myGLCD.setTextColor(BLACK); } myGLCD.print(":", 290, 5); prevDvoet = curmillis; Dvoet=!Dvoet;}
}// end loop
void fastinit() {
digitalWrite (TX_PCM, HIGH); // bus idle
delay(1500);
digitalWrite (TX_PCM, LOW); // first part fastinit (25 ms LOW)
delay(25);
digitalWrite (TX_PCM, HIGH); // second part fastinit (25 ms HIGH)
delay(25);
K_LINE_PCM.begin(10400);
sendMessagePCM(INIT); // send start communication message
}
void receivePCM () {
if (K_LINE_PCM.available() ){
// первый старт байт
if (header == 0 && Delay){TIMER_DELAY ; MessageRx_PCM[0]=K_LINE_PCM.read();
if (MessageRx_PCM[0]!=0xFF && bitRead (MessageRx_PCM[0],7)){header = 1; RESETheader_timer = 1; prevRESETheader = curmillis;
#ifdef debugPCM
Serial.print (F("Receive PCM: ")); printDebugRX(MessageRx_PCM[0]);
#endif
}
}
// второй старт байт
if (header == 1 && Delay){TIMER_DELAY ; MessageRx_PCM[1]=K_LINE_PCM.read();
#ifdef debugPCM
printDebugRX (MessageRx_PCM[1]);
#endif
if (MessageRx_PCM[1]==DIAG_address){ header = 2;}
else {
#ifdef debugPCM
Serial.println(F(" PCM Message fail address"));
#endif
header = 0; RESETheader_timer = 0;}}
// третий старт байт
if (header == 2 && Delay){
TIMER_DELAY ;
MessageRx_PCM[2]=K_LINE_PCM.read();
#ifdef debugPCM
printDebugRX (MessageRx_PCM[2]);
#endif
if (MessageRx_PCM[2]==PCM_address){ message_size = MessageRx_PCM[0]; prevRESETheader = curmillis;
if (MessageRx_PCM[0] !=0x80) {header = 4; bitWrite (message_size, 7 , 0);j=3;n=3;}
else {header = 3; j=4;n=4;}
if (message_size > bufsize) message_size = bufsize; crc = 0;}
else {header = 0;
#ifdef debugPCM
Serial.println(F("PCM Message fail address"));
#endif
RESETheader_timer = 0;}
}
// если размер сообщения указан в дополнительном байте (нулевой байт 0x80) читаем этот дополнительный байт:
if (header == 3 && Delay){
TIMER_DELAY ; prevRESETheader = curmillis;
MessageRx_PCM[3]=K_LINE_PCM.read();
#ifdef debugPCM
printDebugRX(MessageRx_PCM[3]);
#endif
message_size = MessageRx_PCM[3];
if (message_size > bufsize) message_size = bufsize;
crc = 0; header = 4;
}
// пишем тело сообщения
if (header == 4 && Delay && j< message_size+n+1) {
MessageRx_PCM[j] = K_LINE_PCM.read(); prevRESETheader = curmillis;
if (j<message_size+n) crc+= MessageRx_PCM[j]; // подсчёт КС
if (j==message_size+n) header = 5;
TIMER_DELAY ;
#ifdef debugPCM
printDebugRX(MessageRx_PCM[j]);
#endif
j++; }
}
// сообщение приняли, действуем
if (header == 5) {TIMER_DELAY ;
#ifdef debugPCM
Serial.println();
#endif
NOanswer_timer = 0; noanswers = 0; // сбрасываем таймер контроля неответов
for(byte i = 0; i<n; i++) crc+=MessageRx_PCM[i]; // прибавляем к контрольной сумме старт байты
// если контрольная сумма верна:
if ( crc == MessageRx_PCM[message_size+n])
{
#ifdef debugPCM
Serial.print (F("Received message is OK! Checksum is correct!")); Serial.print (F(" ")); Serial.println (millis()); // Если КС совпала, тут чёнибудь нужное делаем
printDebugRX_CSgood();
#endif
if (MessageRx_PCM[n]==0xC1 && MessageRx_PCM[n+1]==0x6B && MessageRx_PCM[n+2]==0x8F) {
if (currentPage!=3) {request = PID; RequestPeriod = 70;} else request = PRESENT, RequestPeriod = 4000; prevRequest = curmillis; // receive good INIT
}
else if (MessageRx_PCM[n]==0x58) Troublecodes (); // DTC
else if (MessageRx_PCM[n]==0x54 && MessageRx_PCM[n+1]==0xFF && MessageRx_PCM[n+2]==0x00){ request = PRESENT; RequestPeriod = 4000; prevRequest = curmillis;} // DTC are cleared
else if (MessageRx_PCM[n]==0x61 && MessageRx_PCM[n+1]==0x01) {dataVars() ; RequestPeriod = 70; prevRequest = curmillis; } // receive DataStream
}
// если контрольная сумма не совпала:
#ifdef debugPCM
else Serial.println("CRC fail!!!" );
#endif
message_size = 0; header=0; RESETheader_timer = 0; j=3; crc = 0;
}
// таймер ожидания байт (для успевания появления данных в буфере UART)
if (!Delay && curmillis - timerdelay > waitbyte_RX) Delay = 1;
// таймер сброса целостности сообщения (если данные оборвались посередине сообщения)
if (RESETheader_timer && curmillis - prevRESETheader > 200) {
#ifdef debugPCM
Serial.println(F("Message fail timeout"));
#endif
RESETheader_timer = 0; header = 0;}
// если нет ответа после запроса: +1 к счетчику неответов. Если накопилось 6 и более: делаем реинит.
if (request!=INIT && NOanswer_timer && curmillis - prev_NOanswer > RequestPeriod - RequestPeriod/10)
{
NOanswer_timer = 0; noanswers++;
if (noanswers>=6) { noanswers = 0; request = INIT; RequestPeriod = 3500;}
}
}// end receivePCM
void Troublecodes ()
{
if (MessageRx_PCM[n]==0x58 && MessageRx_PCM[n+1]==0x00){
myGLCD.clrScr();
drawscreen_three();
myGLCD.print("NO DTC", 165, 145);
}
// при получении сообщения о наличии ошибок DTC разберем сообщение выведем на экран ошибки
if (MessageRx_PCM[n]==0x58 && MessageRx_PCM[n+1]>0){
myGLCD.clrScr();
drawscreen_three();
for (int i=0; i<MessageRx_PCM[n+8-7]; i++ ) {
int y = i*35;
bool nolA=0; bool nolB =0;
if (!bitRead(MessageRx_PCM[n+11-7+(i*3)],6) && bitRead(MessageRx_PCM[n+11-7+(i*3)],7)){ myGLCD.setTextColor(GREEN, BLACK);
myGLCD.print(" -Passive-", 300, (75+y));} // если DTC пасивныый делаем цвет зеленый
if (bitRead(MessageRx_PCM[n+11-7+(i*3)],7) && bitRead(MessageRx_PCM[n+11-7+(i*3)],6)) { myGLCD.setTextColor(RED, BLACK);
myGLCD.print(" -Active-", 300, (75+y));} // если DTC активный, делаем цвет красный
myGLCD.print("ERROR ", 50, (75+y));
myGLCD.printNumI((i+1), 150, (75+y));
if (!bitRead(MessageRx_PCM[n+9-7+(i*3)],6) && !bitRead(MessageRx_PCM[n+9-7+(i*3)],7)) myGLCD.print(": P", 170, (75+y));
if (bitRead(MessageRx_PCM[n+9-7+(i*3)],6) && !bitRead(MessageRx_PCM[n+9-7+(i*3)],7)) myGLCD.print(": C", 170, (75+y));
if (!bitRead(MessageRx_PCM[n+9-7+(i*3)],6) && bitRead(MessageRx_PCM[n+9-7+(i*3)],7)) myGLCD.print(": B", 170, (75+y));
if (bitRead(MessageRx_PCM[n+9-7+(i*3)],6) && bitRead(MessageRx_PCM[n+9-7+(i*3)],7)) myGLCD.print(": U", 170, (75+y));
if (MessageRx_PCM[n+9-7+(i*3)]==0x00) {myGLCD.print("00", 230, (75+y)); nolA = 1;}
if (MessageRx_PCM[n+9-7+(i*3)]<=0x0F&&MessageRx_PCM[n+9-7+(i*3)]!=0) {myGLCD.print("0", 230, (75+y)); nolA = 1;}
if (nolA)myGLCD.print(String (MessageRx_PCM[n+9-7+(i*3)],HEX), 246, (75+y));
else myGLCD.print(String (MessageRx_PCM[n+9-7+(i*3)],HEX), 230, (75+y));
if (MessageRx_PCM[n+10-7+(i*3)]==0x00) {myGLCD.print("00", 262, (75+y)); nolB = 1;}
if (MessageRx_PCM[n+10-7+(i*3)]<=0x0F&&MessageRx_PCM[n+10-7+(i*3)]!=0) {myGLCD.print("0", 262, (75+y)); nolB = 1;}
if (nolB)myGLCD.print(String (MessageRx_PCM[n+10-7+(i*3)]),HEX, 278, (75+y));
else myGLCD.print(String (MessageRx_PCM[n+10-7+(i*3)],HEX), 262, (75+y));}}
request = PRESENT; RequestPeriod = 4000; prevRequest = curmillis;
}
void dataVars()
{
//Barom = MessageRx_PCM[39];
L100 = (float)LHor*100.0/(float)Speed;
LHor = (float)RPM* (float)InjQua*2.00/1000.0*60.00/1000.0/0.85;
MAF = ((MessageRx_PCM[n+22]*256)+MessageRx_PCM[n+23])/10;
BoostPres = ((MessageRx_PCM[n+24]*256)+MessageRx_PCM[n+25])/1000.0;
RPM = (MessageRx_PCM[n+35-7]*256)+MessageRx_PCM[n+36-7];
EGRmg = ((MessageRx_PCM[n+37-7]*256)+MessageRx_PCM[n+38-7])/10.0;
BoostPresCom = ((MessageRx_PCM[n+41-7]*256)+MessageRx_PCM[n+42-7])/1000.0;
Speed = ((MessageRx_PCM[n+47-7]*256)+MessageRx_PCM[n+48-7])/100;
DesaInjQua = ((MessageRx_PCM[n+53-7]*256)+MessageRx_PCM[n+54-7])/100.0;
InjQua = ((MessageRx_PCM[n+55-7]*256)+MessageRx_PCM[n+56-7])/100.0;
StaDaliv = ((MessageRx_PCM[n+57-7]*256)+MessageRx_PCM[n+58-7])/100.0;
PumpRPM = (MessageRx_PCM[n+59-7]*256)+MessageRx_PCM[n+60-7];
EGRPul = ((MessageRx_PCM[n+65-7]*256)+MessageRx_PCM[n+66-7])/100.0;
SolenPul = ((MessageRx_PCM[n+67-7]*256)+MessageRx_PCM[n+68-7])/100.0;
SolenPre = ((MessageRx_PCM[n+73-7]*256)+MessageRx_PCM[n+74-7])/100.0;
DesInj = ((MessageRx_PCM[n+75-7]*3)+(MessageRx_PCM[n+76-7])/100.0)+0.3;
ActInj = ((MessageRx_PCM[n+19-7]*3)+(MessageRx_PCM[n+20-7])/100.0)+0.3;
//TempAir = ((MessageRx_PCM[n+77-7]*26)-278)+MessageRx_PCM[n+78-7]/10.0;
//Temp = ((MessageRx_PCM[n+17-7]*26)-278)+MessageRx_PCM[n+18-7]/10.0;
//TempOil = ((MessageRx_PCM[n+21-7]*26)-278)+MessageRx_PCM[n+22-7]/10.0;
//TempFuel = ((MessageRx_PCM[n+61-7]*26)-278)+MessageRx_PCM[n+62-7]/10.0;
//ниже идут расчетные формулы более точные чем те что закоментированы выше
int A = 0;
if (MessageRx_PCM[n+77-7]<=0x0A) A = 277;
if (MessageRx_PCM[n+77-7]==0x0B || MessageRx_PCM[n+77-7]==0x0C) A = 278;
if (MessageRx_PCM[n+77-7]>=0x0D) A = 279;
double B = MessageRx_PCM[n+78-7]/10.0;
double cel , drob ;
drob = modf(B, &cel);
if (drob>0.6) cel++;
TempAir = ((MessageRx_PCM[n+77-7]*26)-A)+cel;
if (MessageRx_PCM[n+17-7]<=0x0A) A = 277;
if (MessageRx_PCM[n+17-7]==0x0B || MessageRx_PCM[n+17-7]==0x0C) A = 278;
if (MessageRx_PCM[n+17-7]>=0x0D) A = 279;
B = MessageRx_PCM[n+18-7]/10.0;
drob = modf(B, &cel);
if (drob>0.6) cel++;
Temp = ((MessageRx_PCM[n+17-7]*26)-A)+cel;
if (MessageRx_PCM[n+21-7]<=0x0A) A = 277;
if (MessageRx_PCM[n+21-7]==0x0B || MessageRx_PCM[n+21-7]==0x0C) A = 278;
if (MessageRx_PCM[n+21-7]>=0x0D) A = 279;
B = MessageRx_PCM[n+22-7]/10.0;
drob = modf(B, &cel);
if (drob>0.6) cel++;
TempOil = ((MessageRx_PCM[n+21-7]*26)-A)+cel;
if (MessageRx_PCM[n+61-7]<=0x0A) A = 277;
if (MessageRx_PCM[n+61-7]==0x0B || MessageRx_PCM[n+61-7]==0x0C) A = 278;
if (MessageRx_PCM[n+61-7]>=0x0D) A = 279;
B = MessageRx_PCM[n+62-7]/10.0;
drob = modf(B, &cel);
if (drob>0.6) cel++;
TempFuel = ((MessageRx_PCM[n+61-7]*26)-A)+cel;
//----------------------------------------------------------
//страниц HOME
//----------------------------------------------------------
//myGLCD.setBackColor(RED);
myGLCD.setTextColor(WHITE, BLACK);
//myGLCD.setBackColor(RED);
myGLCD.printNumI(Speed, 350, 7, 3);
if (currentPage == '0') {
if (LHor != LHor_last || reNew) {myGLCD.printNumF(LHor, 1, 60, 40, '.',5); LHor_last=LHor;}
if (L100 != L100_last || reNew) {myGLCD.printNumF(L100, 1, 210, 40,'.',5 ); L100_last=L100;}
if (L100M != L100M_last || reNew) {myGLCD.printNumF(L100M, 1, 60, 75,'.',5 ); L100M_last=L100M;}
if (L100SR_TFT != L100SR_TFT_last || reNew) {myGLCD.printNumF(L100SR_TFT, 1, 210, 75,'.',5 ); L100SR_TFT_last=L100SR_TFT;}
if (kmREFUELING != kmREFUELING_last || reNew) {myGLCD.printNumI(kmREFUELING, 60, 110,5 ); kmREFUELING_last=kmREFUELING;}
//if (Fuel<53)
if (Fuel != Fuel_last || reNew) {myGLCD.printNumF(Fuel, 1, 210, 110,'.',5); Fuel_last=Fuel;}
//else myGLCD.print("MAX", 210, 110);
if (kmTrip != kmTrip_last || reNew) {myGLCD.printNumF(kmTrip, 1, 60, 145,'.',5); kmTrip_last=kmTrip;}
if (FuelTrip != FuelTrip_last || reNew) {myGLCD.printNumF(FuelTrip, 1, 210, 145,'.',5); FuelTrip_last=FuelTrip;}
if (PumpRPM != PumpRPM_last || reNew) {myGLCD.printNumI(PumpRPM, 210, 180,5); PumpRPM_last=PumpRPM;}
if (RPM != RPM_last || reNew) {myGLCD.printNumI(RPM, 210, 215,5); RPM_last=RPM;}
if (Fuel2 != Fuel2_last || reNew) {myGLCD.printNumF(Fuel2, 1, 0, 215,'.',5); Fuel2_last=Fuel2;}
if (Temp != Temp_last || reNew) {myGLCD.printNumI(Temp, 415, 40, 3); Temp_last=Temp;}
if (TempOil != TempOil_last || reNew) {myGLCD.printNumI(TempOil, 415, 75, 3); TempOil_last=TempOil;}
if (TempFuel != TempFuel_last || reNew) {myGLCD.printNumI(TempFuel, 415, 110,3); TempFuel_last=TempFuel;}
//myGLCD.printNumI(sensors.getTempCByIndex(0), 415, 145 , 3);
if (t != t_last || reNew) {myGLCD.printNumI(t, 415, 180, 3); t_last=t;}
if (TempAir != TempAir_last || reNew) {myGLCD.printNumI(TempAir, 415, 215, 3); TempAir_last=TempAir;}
}
//----------------------------------------------------------
//страниц INF1
//----------------------------------------------------------
if (currentPage == '1') {
if (StaDaliv != StaDaliv_last || reNew) {myGLCD.printNumF(StaDaliv,1, 360, 40,'.', 3); StaDaliv_last=StaDaliv;}
if (DesInj != DesInj_last || reNew) {myGLCD.printNumF(DesInj,1, 395, 75, '.', 4); DesInj_last=DesInj;}
if (ActInj != ActInj_last || reNew) {myGLCD.printNumF(ActInj,1, 395, 110,'.', 4); ActInj_last=ActInj;}
if (DesaInjQua != DesaInjQua_last || reNew) {myGLCD.printNumF(DesaInjQua,1, 395, 145,'.', 4);DesaInjQua_last=DesaInjQua;}
if (InjQua != InjQua_last || reNew) {myGLCD.printNumF(InjQua,1, 395, 180,'.', 4); InjQua_last=InjQua;}
if (MAF != MAF_last || reNew) {myGLCD.printNumI(MAF, 170, 215, 4); MAF_last=MAF;}
if (h != h_last || reNew) {myGLCD.printNumF(h, 1, 418, 215); h_last=h;}
}
//----------------------------------------------------------
//страниц INF2
//----------------------------------------------------------
if (currentPage == '2') {
if (BoostPres != BoostPres_last || reNew) {myGLCD.printNumF(BoostPres,1, 395, 40,'.', 4); BoostPres_last=BoostPres;}
if (BoostPresCom != BoostPresCom_last || reNew) {myGLCD.printNumF(BoostPresCom,1, 395, 75,'.', 4); BoostPresCom_last=BoostPresCom;}
if (EGRmg != EGRmg_last || reNew) {myGLCD.printNumI(EGRmg, 395, 110, 4); EGRmg_last=EGRmg;}
if (EGRPul != EGRPul_last || reNew) {myGLCD.printNumF(EGRPul,1, 410, 145,'.', 3); EGRPul_last=EGRPul;}
if (SolenPul != SolenPul_last || reNew) {myGLCD.printNumF(SolenPul, 1, 395, 180,'.', 4); SolenPul_last=SolenPul;}
if (SolenPre != SolenPre_last || reNew) {myGLCD.printNumF(SolenPre, 0, 410, 215,'.', 3); SolenPre_last=SolenPre;}
}
}
void sendMessagePCM(const byte &command)
{
#ifdef debugPCM
Serial.print (F("Send request ")); Serial.print (textRequest[command]); Serial.print (F(" to PCM ")); Serial.println (millis());
#endif
if (command != INIT) {NOanswer_timer = 1; prev_NOanswer = curmillis;} //т.к. сейчас будем делать запрос, то запускаем таймер контроля неответов
byte size = PCM_Message_TX[command][0];
const byte siZe = size+4;
byte Mes[siZe];
byte Checksum = 0;
for(byte i=0; i<siZe; i++) {
if (i==0) {Mes[i]=size; bitWrite(Mes[i], 7 , 1);}
if (i==1) Mes[i] = PCM_address;
if (i==2) Mes[i] = DIAG_address;
if (i==3) {for (byte t=1; t<size+1; t++ ) {
Mes[i]=PCM_Message_TX [command][t];
Checksum+=Mes[i] ;
K_LINE_PCM.write (Mes[i]);
if (command == INIT) delay (5); else delay (delaybyte_TX);
K_LINE_PCM.read();
i++;}}
if (i!=siZe-1) Checksum+=Mes[i];
else Mes[i] = Checksum;
K_LINE_PCM.write (Mes[i]);
if (command == INIT) delay (5); else delay (delaybyte_TX);
K_LINE_PCM.read();
}
}// end sendMessagePCM
#if defined debugPCM or debugGAUGE
void printDebugRX (const byte &inbyte) {if (inbyte<=15) Serial.print(F("0")); Serial.print (inbyte, HEX); Serial.print (F(" "));}
#endif
#ifdef debugPCM
void printDebugRX_CSgood(){
if (MessageRx_PCM[n]==0xC1 && MessageRx_PCM[n+1]==0x6B && MessageRx_PCM[n+2]==0x8F) {Serial.println (F(" Initialization OK!!!!")); }
else if (MessageRx_PCM[n]==0x58 && MessageRx_PCM[n+1]==0x00) {Serial.println (F(" NO DTC "));}
else if (MessageRx_PCM[n]==0x58 && MessageRx_PCM[n+1] >0x00) {Serial.println (F(" DTC is found!"));}
else if (MessageRx_PCM[n]==0x54 && MessageRx_PCM[n+1]==0xFF && MessageRx_PCM[n+2]==0x00){Serial.println (F(" DTC CLEARED "));}
else if (MessageRx_PCM[n]==0x61 && MessageRx_PCM[n+1]==0x01) {Serial.println (F(" Receive PCM DATAstream"));}}
#endif
void Menu () {
TouchHOME();
if (currentPage == '0') {
TouchINF1();
TouchINF2();
TouchCHECK(); }
if (currentPage == '1') {
TouchINF2();
TouchCHECK(); }
if (currentPage == '2') {
TouchINF1();
TouchCHECK(); }
if (currentPage == '3') {
TouchREAD();
TouchERASE(); }}
void drawHomeScreen() {
reNew = 1;
line() ;
Watch ();
myGLCD.print("/", 115, 7);
myGLCD.print("/", 160, 7);
myGLCD.setTextColor(RED, BLACK); // цвет линии и текста красный
myGLCD.drawLine(295,35,295,248); // линия вертикальная
myGLCD.drawLine(145,35,145,178); // линия вертикальная
myGLCD.drawLine(80,178,80,247); // линия вертикальная
myGLCD.print("L/H", 10, 40);
myGLCD.print("L/A", 148, 40);
myGLCD.print("L/V", 10, 75);
myGLCD.print("L/M", 148, 75);
myGLCD.print("D/K", 10, 110);
myGLCD.print("D/L", 148, 110);
myGLCD.print("V/K", 10, 145);
myGLCD.print("V/L", 148, 145);
myGLCD.print("PUMP RPM", 82, 180);
myGLCD.print("ENGI RPM", 82, 215);
myGLCD.print("D/La", 10, 180);
myGLCD.print("Motor C", 300, 40);
myGLCD.print("OIL C", 300, 75);
myGLCD.print("FUEL C", 300, 110);
myGLCD.print("INTER C", 300, 145);
myGLCD.print("EXTER C", 300, 180);
myGLCD.print("INTAIR C", 300, 215);
//myGLCD.setTextColor(RED);
myGLCD.drawRoundRect (15, 255, 145, 310);
myGLCD.print("INF 1", 55, 270);
myGLCD.drawRoundRect (175, 255, 305, 310);
myGLCD.print("INF 2", 215, 270);
myGLCD.drawRoundRect (335, 255, 465, 310);
myGLCD.print("CHECK", 365, 270);
myGLCD.drawRoundRect (1, 1, 77, 37);
myGLCD.print("HOME", 10, 7);
myGLCD.print("Km/h", 410, 7);
}
//-------------------------------------------------
void drawscreen_one() {
reNew = 1;
line() ;
Watch ();
myGLCD.print("/", 115, 7);
myGLCD.print("/", 160, 7);
myGLCD.setTextColor(RED, BLACK); // цвет линии и текста красный
myGLCD.print("Start of Delivery *CA:", 10, 40);
myGLCD.print("Desir inject Start *CA:", 10, 75);
myGLCD.print("Actua Inject Start *CA:", 10, 110);
myGLCD.print("Desir Inject Quan mg/s:", 10, 145);
myGLCD.print("Actu Inject Quant mg/s:", 10, 180);
myGLCD.print("MAF mg/s:", 10, 215);
myGLCD.print("Humedad %:", 255, 215);
//myGLCD.setTextColor(RED);
myGLCD.drawRoundRect (175, 255, 305, 310);
myGLCD.print("INF 2", 215, 270);
myGLCD.drawRoundRect (335, 255, 465, 310);
myGLCD.print("CHECK", 365, 270);
myGLCD.drawRoundRect (1, 1, 77, 37);
myGLCD.print("HOME", 10, 7);
myGLCD.print("Km/h", 410, 7);
}
//-------------------------------------------------
void drawscreen_two() {
reNew = 1;
line() ;
Watch ();
myGLCD.print("/", 115, 7);
myGLCD.print("/", 160, 7);
myGLCD.setTextColor(RED, BLACK); // цвет линии и текста красный
myGLCD.print("Boost Press Bar:", 10, 40);
myGLCD.print("Boost Press Com Bar:", 10, 75);
myGLCD.print("EGR command mg/s:", 10, 110);
myGLCD.print("EGR Pulse Ratio %:", 10, 145);
myGLCD.print("Solenoide Pulse %:", 10, 180);
myGLCD.print("Solenoide Boost %:", 10, 215);
//myGLCD.setColor(RED);
myGLCD.drawRoundRect (15, 255, 145, 310);
myGLCD.print("INF 1", 55, 270);
myGLCD.drawRoundRect (335, 255, 465, 310);
myGLCD.print("CHECK", 365, 270);
myGLCD.drawRoundRect (1, 1, 77, 37);
myGLCD.print("HOME", 10, 7);
myGLCD.print("Km/h", 410, 7);
}
//----------------------------------------------------------------------------
void drawscreen_three() {
reNew = 1;
Watch ();
myGLCD.print("/", 115, 7);
myGLCD.print("/", 160, 7);
myGLCD.setTextColor(RED, BLACK); // цвет линии красный
myGLCD.drawLine(1,35,479,35); // линия горизонтальная
myGLCD.drawLine(1,248,479,248); // линия горизонтальная
//myGLCD.setTextColor(RED);
myGLCD.drawRoundRect (15, 255, 145, 310);
myGLCD.print("ERASE", 55, 270);
myGLCD.drawRoundRect (335, 255, 465, 310);
myGLCD.print("READ", 365, 270);
myGLCD.drawRoundRect (1, 1, 77, 37);
myGLCD.print("HOME", 10, 5);
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//кнопки тач . координаты и переходы
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void TouchHOME(){
TSPoint p = ts.getPoint();
pinMode(XM, OUTPUT);
pinMode(YP, OUTPUT);
if (p.z > 10 && p.z < 1000)
{if (p.x > 140 && p.x < 320 && p.y > 140 && p.y < 260 && p.z > MINPRESSURE && p.z < MAXPRESSURE)
{ myGLCD.drawRoundRect (1, 1, 77, 37);
currentPage = '0';
request = PID; RequestPeriod = 10; prevRequest = curmillis; // на PCM в этом окне посылается запрос текущих параметров
myGLCD.clrScr();
drawHomeScreen();
x = 0;
y = 0;
p.z = 0;}}}
void TouchINF1(){
TSPoint p = ts.getPoint();
pinMode(XM, OUTPUT);
pinMode(YP, OUTPUT);
if (p.z > 10 && p.z < 1000)
{
if (p.x > 150 && p.x < 450 && p.y > 770 && p.y < 890 && p.z > MINPRESSURE && p.z < MAXPRESSURE)
{ myGLCD.drawRoundRect (15, 255, 145, 310);
currentPage = '1';
request = PID; RequestPeriod = 10; prevRequest = curmillis; // на PCM в этом окне посылается запрос текущих параметров
myGLCD.clrScr();
drawscreen_one();
x = 0;
y = 0;
p.z = 0;}}}
void TouchINF2(){
TSPoint p = ts.getPoint();
pinMode(XM, OUTPUT);
pinMode(YP, OUTPUT);
if (p.z > 10 && p.z < 1000)
{
if (p.x > 450 && p.x < 680 && p.y > 770 && p.y < 890 && p.z > MINPRESSURE && p.z < MAXPRESSURE)
{ myGLCD.drawRoundRect (175, 255, 305, 310);
currentPage = '2';
request = PID; RequestPeriod = 600; prevRequest = curmillis; // на PCM в этом окне посылается запрос текущих параметров
myGLCD.clrScr();
drawscreen_two();
x = 0;
y = 0;
p.z = 0;}}}
void TouchCHECK(){
TSPoint p = ts.getPoint();
pinMode(XM, OUTPUT);
pinMode(YP, OUTPUT);
if (p.z > 10 && p.z < 1000)
{
if (p.x > 690 && p.x < 950 && p.y > 770 && p.y < 890 && p.z > MINPRESSURE && p.z < MAXPRESSURE)
{ myGLCD.drawRoundRect (335, 255, 465, 310);
currentPage = '3';
// request = DTCREAD; RequestPeriod = 10; prevRequest = curmillis; // на PCM в этом окне посылается запрос чтения ошибок
myGLCD.clrScr();
drawscreen_three();
x = 0;
y = 0;
p.z = 0;}}}
void TouchREAD(){
TSPoint p = ts.getPoint();
pinMode(XM, OUTPUT);
pinMode(YP, OUTPUT);
if (p.z > 10 && p.z < 1000)
{
if (p.x > 690 && p.x < 950 && p.y > 770 && p.y < 890 && p.z > MINPRESSURE && p.z < MAXPRESSURE)
{ myGLCD.drawRoundRect (335, 255, 465, 310);
request = DTCREAD; RequestPeriod = 300; prevRequest = curmillis; // на PCM при нажатии этой кнопки посылается запрос чтения ошибок
x = 0;
y = 0;
p.z = 0;}}}
void TouchERASE(){
TSPoint p = ts.getPoint();
pinMode(XM, OUTPUT);
pinMode(YP, OUTPUT);
if (p.z > 10 && p.z < 1000)
{
if (p.x > 150 && p.x < 450 && p.y > 770 && p.y < 890 && p.z > MINPRESSURE && p.z < MAXPRESSURE)
{myGLCD.drawRoundRect (15, 255, 145, 310);
request = DTCERASE; RequestPeriod = 300; prevRequest = curmillis; // на PCM при нажатии этой кнопки посылается запрос удаления ошибок
x = 0;
y = 0;
p.z = 0;}}}
////////////////////////////////////////////////////////////////////////////////////////
//прорисовка линий
///////////////////////////////////////////////////////////////////////////////////////
void line() {
//myGLCD.setTextColor(RED); // цвет линии красный
myGLCD.drawLine(1,35,479,35); // линия горизонтальная
myGLCD.drawLine(1,73,479,73); // линия горизонтальная
myGLCD.drawLine(1,108,479,108); // линия горизонтальная
myGLCD.drawLine(1,143,479,143); // линия горизонтальная
myGLCD.drawLine(1,178,479,178); // линия горизонтальная
myGLCD.drawLine(1,212,479,212); // линия горизонтальная
myGLCD.drawLine(1,248,479,248); // линия горизонтальная
}
void Watch (){
DateTime now = rtc.now();
int minut = now.minute();
int hour = now.hour();
int mon = now.month();
int date = now.day();
int Year = now.year();
static int minut_last;
static int hour_last;
static int mon_last;
static int date_last;
static int Year_last;
myGLCD.setTextColor(WHITE, BLACK); //белый цвет цифры
if (date != date_last || reNew){ myGLCD.printNumI(date, 85, 7, 2, '0'); date_last = date; }
if (mon!=mon_last || reNew){myGLCD.printNumI(date, 130, 7, 2, '0'); mon_last = mon; }
if (Year!=Year_last || reNew) { myGLCD.printNumI(Year, 175, 7); Year_last = Year; }
if (hour!=hour_last || reNew){ myGLCD.printNumI(date, 255, 7, 2, '0'); hour_last = hour; }
if (minut!=minut_last || reNew ){ myGLCD.printNumI(date, 300, 7, 2, '0'); minut_last = minut; }
reNew = 0;
}
Там где ты обьявлял новые переменные ..._last - типы должны совпадать ! Где int, то и новая int. Где float, то и новая float !!! (а то ты кур к свиньям приравниваешь)
Viki, может всё таки закажешь этот, а то реально ппц тема уже на две тыщи постов раздувается. Может этот тфт побыстрее будет. Только спросить у китайца с какой либой работает.
Не, уже победа. обновление 1 секудна. даже вроде чутка меньше :) одни косяк. время и дата не коректны. показывает 02/02/2019 02:02. перезалил время и дату думал просто сбилось. но нет тоже самое 02/02/2019 02:02
#include <Adafruit_GFX.h>
#include <MCUFRIEND_kbv.h>
#include <UTFTGLUE.h>//use GLUE class and constructor
#include "TouchScreen.h"
#include <stdint.h>
#include <SPI.h>
#include <EEPROM.h>
//MCUFRIEND_kbv tft;
#include "Fonts/Chosence_Bold16pt7b.h";
#define MINPRESSURE 200
#define MAXPRESSURE 1000
//pin 20 SCL , 21 SDA датчик реального времени
#include <Wire.h>
#include "RTClib.h"
RTC_DS3231 rtc;
UTFTGLUE myGLCD(0x1581,A2,A1,A3,A4,A0); //all dummy args
const int XP = 6, XM = A2, YP = A1, YM = 7;
const int TS_LEFT = 136, TS_RT = 907, TS_TOP = 139, TS_BOT = 942;
TouchScreen ts = TouchScreen(XP, YP, XM, YM, 300);
uint16_t ID;
int x, y;
char currentPage;
float h; int h_last = 1;
float t; int t_last = 1;
bool Dvoet = 0;
bool reNew = 0;
#define BLACK 0x0000
#define WHITE 0xFFFF
#define RED 0xF800
#define GREEN 0x07E0
#include <SoftwareSerial.h>
#define TX_PCM 13
SoftwareSerial K_LINE_PCM (12, TX_PCM); //RХ,TХ
#define PCM_address 0x11 // адрес PCM
#define DIAG_address 0xF1 // адрес диагностики
#define debugPCM // раскоментировать эту строку для отладки в Serial порту обмена с PCM
//#define debugGAUGE // раскоментировать эту строку для отладки в Serial порту обмена co щитком приборов
uint32_t curmillis = 0; // снимок текущего времени
uint32_t prevRequest = 0; // таймер периодических запосов на PCM
uint16_t RequestPeriod = 3500; // периодичность запросов на PCM
uint32_t prevRESETheader=0; // таймер сброса сообщения, если данные оборвались посередине сообщения
bool RESETheader_timer; // таймер сброса сообщения, если данные оборвались посередине сообщения
uint32_t prev_NOanswer=0; // таймер контроля неответов от ЭБУ после подачи запросов
bool NOanswer_timer = 0; // таймер контроля неответов от ЭБУ после подачи запросов
byte noanswers = 0; // количество подряд неответов от ЭБУ
uint32_t timerdelay = 0; // таймер ожидания байт (для успевания появления данных в буфере UART)
bool Delay = 0; // таймер ожидания байт (для успевания появления данных в буфере UART)
byte waitbyte_RX = 1; // задержка, мс для успевания появления данных в буфере RX
// (подрегулировать в зависимости от уровня жизнидеятельности на Марсе)
#define TIMER_DELAY Delay = 0; timerdelay = curmillis // включение этого таймера
byte delaybyte_TX = 1; // задержка между отправкой байт в запросах, мс
byte header = 0; // состояние заголовка
byte message_size = 0; // размер тела сообщения
byte j = 3; // инкремент
byte n = 3; // количество старт байт
const byte bufsize = 150; // размер буфера принятого сообщения
byte MessageRx_PCM [bufsize] = {0}; // буфер принятого сообщения
byte crc =0; // байт контрольной суммы
// возможные варианты запросов на ЭБУ:
enum REQUEST {
INIT,
PID,
DTCERASE,
DTCREAD,
PRESENT,
};
// текстовки запросов для отладки
char* textRequest[] = {
"INIT",
"PID_2101",
"DTC_ERASE",
"DTC_READ",
"PRESENT",
} ;
// сами запросы
byte PCM_Message_TX[][5] = {
{1, 0x81, 0,0,0}, // запрос инициализации
{2, 0x21,0x01, 0,0}, // запрос пид 2101
{3, 0x14,0xFF,0x00, 0}, // запрос на стирание ошибок
{4, 0x18,0x00,0xFF,0x00 }, // запрос на чтение ошибок
{1, 0x3E, 0,0,0}, // запрос присутствия
};
byte request = INIT; // переменная, показывающая какой запрос будем делать
//-------------------------------------------переменные бортовика
float L100M = 0; float L100M_last = 1; //расход на 100 км измеренный за поездку
float L100 = 0; float L100_last = 1; //мгновенный расход литров на 100км
float LHor = 0; float LHor_last = 1; //мгновенный расход топлива литров в час
float L100SR = 0; //расход литров на 100км измеренный раз в интервал kmL
float L100SR_TFT = 0; float L100SR_TFT_last = 1; // самый средний из расходов на 100км, он выводится на экран
int L100_Eeprom[11]= {10,10,10,10,10,10,10,10,10,10,10};
int FuelZamer[10]= {0}; // массив для измерения уровня (количества) топлива
int ZamerNumber = 0; // номер замера уровня (количества) топлива
int n_eeprom = 0; // текущий адрес ячейки еепром для записи расхода
int MAF = 0; int MAF_last = 1; //26,27 байты Sensor de flujo de aire en masa
float BoostPres = 0; float BoostPres_last = 1; //28,29 байты Presión de refuerzo
int RPM = 0; int RPM_last = 1; //32,33 байты Velocidad del motor
int EGRmg = 0; int EGRmg_last = 1; //34,35 байты Comando EGR (Comando de recirculación de gases de escape)
float BoostPresCom = 0; float BoostPresCom_last = 1; //38,39 байты Comando de presión de refuerzo
int Speed = 0; int Speed_last = 1; //44,45 байты Velocidad del vehículo
float DesaInjQua = 0; float DesaInjQua_last = 1; //50,51 байты Cantidad de inyección deseada
float InjQua = 0; float InjQua_last = 1; //52,53 байты Cantidad de la inyección
float StaDaliv = 0; float StaDaliv_last = 1; //54,55 байты Inicio de la entrega
int PumpRPM = 0; int PumpRPM_last = 1; //56,57 байты Velocidad de la bomba
float EGRPul = 0; float EGRPul_last = 1; //62,63 байты Relación de impulsos EGR (recirculación de gases de escape
float SolenPul = 0; float SolenPul_last = 1; //64,65 байты Velocidad de solenoide de control de nivel de remolino Relación de impulsos
float SolenPre = 0; float SolenPre_last = 1; //70,71 байты Relación de impulsos Presión Electroválvula de presión
float DesInj = 0; float DesInj_last = 1; //72,73 байты Inyección deseada Inicio
float ActInj = 0; float ActInj_last = 1; //16,17 байты Inicio de la inyección real
int TempAir = 0; int TempAir_last = 1; //74,75 байты Temperatura del aire de admisión
int Temp = 0; int Temp_last = 1; //14,15 байты Temperatura del refrigerante
int TempOil = 0; int TempOil_last = 1; //18,19 байты Temperatura del aceite del motor
int TempFuel = 0; int TempFuel_last = 1; //58,59 байты Temperatura del combustible
//все что касается топлива
float Fuel = 0; //остаток топлива
float Fuel2 = 0; float Fuel2_last = 1; //остаток мгновенного топлива байт 16 , датчика в баке
int FuelIGN = 0; // количество топлвива в баке на момент включения зажигания
int Fuel_last = 0; // для формул
bool flagFuelIGN = 0; // флаг записан ли остаток топлива в момент вкл. зажигания
float FuelTrip = 0; float FuelTrip_last = 1; // количество литров топлива, израсходованное за один цикл включения зажигания
//все что касается километража
float kmAge = 0; //пробег, полученный со щитка приборов
int kmAgeIGN = 0; //пробег который был в момент включения зажигания
int kmAge_last = 0; // для формул
bool flagkmAgeIGN = 0; //флаг записан ли пробег в момент вкл. зажигания
float kmTrip = 0; float kmTrip_last = 1; //пробег за один цикл включения зажигания
int kmL = 10; // интервал, через который будет происходить обновление среднего расхода на 100км
int km = 0; // переменная для расчетов
int kmeeprom = 10; // интервал, через который будет происходить подсчет среднеарифмитического расхода L100SR_TFT
int kmTFT = 0; // переменная для расчетов периодического подсчета среднеарифмитического расхода топлива L100SR_TFT
int kmREFUELING = 0; int kmREFUELING_last = 1; // пробег до заправки на остатке топлива
unsigned long prevWatch = 0;
unsigned long prevDvoet = 0;
unsigned long prevData = 0;
void setup() {
uint16_t ID = myGLCD.readID();
if (ID == 0xD3D3) ID = 0x1581; // write-only shield
myGLCD.begin(ID);
myGLCD.InitLCD(3);
myGLCD.clrScr();
myGLCD.setFont(&Chosence_Bold16pt7b);
//myGLCD.fillScreen(WHITE);
//myGLCD.setTextColor(WHITE, BLACK);
//myGLCD.setBackColor(BLACK);
Wire.begin();
rtc.begin();
//загрузка стартовой страницы
currentPage = '0';
drawHomeScreen();
//подсчет среднеарифметического усредненного расхода
for (int i = 0; i < 11; i++) L100_Eeprom [i]= EEPROM.read(i);
for (int i = 0; i < 11; i++) L100SR_TFT = L100SR_TFT + L100_Eeprom [i];
L100SR_TFT = (float)L100SR_TFT/110.0;
if (L100SR_TFT<0) L100SR_TFT = 0;
if (L100SR_TFT>99) L100SR_TFT = 99;
// строка ниже используется для настройки даты и времени часов
// раскоментировать, выставить времая и дату, залить в ардуино. в скетче закоментировать
// обратно и залить еще раз, иначе каждый раз будет по новой выствлятся это же время и дата
// (год, месяц, день, часы, минуты, секунды)
//rtc.adjust(DateTime(2019, 7, 2, 10, 48, 0));
#if defined debugPCM or debugGAUGE
Serial.begin(115200);
#endif
K_LINE_PCM.begin(10400);
pinMode(TX_PCM, OUTPUT);
}
void loop()
{
curmillis = millis(); // снимок текущего времени
if (curmillis - prevRequest > RequestPeriod && header == 0 )
{
if (request == INIT) fastinit(); // при необходимости делаем переподключение к PCM
else {sendMessagePCM(request); // отправляем на PCM текущий запрос
if (request == PID) RequestPeriod = 600;
if (request == DTCERASE || request == DTCREAD) RequestPeriod = 2500;}
prevRequest = curmillis;
}
receivePCM (); // приём сообщений от PCM
if (header == 0) Menu ();
if (curmillis - prevWatch > 3000) { Watch (); prevWatch = curmillis;}
//if (curmillis - prevDvoet > 500) { if (!Dvoet) {myGLCD.setTextColor(WHITE); } else {myGLCD.setTextColor(BLACK); } myGLCD.print(":", 290, 5); prevDvoet = curmillis; Dvoet=!Dvoet;}
}// end loop
void fastinit() {
digitalWrite (TX_PCM, HIGH); // bus idle
delay(1500);
digitalWrite (TX_PCM, LOW); // first part fastinit (25 ms LOW)
delay(25);
digitalWrite (TX_PCM, HIGH); // second part fastinit (25 ms HIGH)
delay(25);
K_LINE_PCM.begin(10400);
sendMessagePCM(INIT); // send start communication message
}
void receivePCM () {
if (K_LINE_PCM.available() ){
// первый старт байт
if (header == 0 && Delay){TIMER_DELAY ; MessageRx_PCM[0]=K_LINE_PCM.read();
if (MessageRx_PCM[0]!=0xFF && bitRead (MessageRx_PCM[0],7)){header = 1; RESETheader_timer = 1; prevRESETheader = curmillis;
#ifdef debugPCM
Serial.print (F("Receive PCM: ")); printDebugRX(MessageRx_PCM[0]);
#endif
}
}
// второй старт байт
if (header == 1 && Delay){TIMER_DELAY ; MessageRx_PCM[1]=K_LINE_PCM.read();
#ifdef debugPCM
printDebugRX (MessageRx_PCM[1]);
#endif
if (MessageRx_PCM[1]==DIAG_address){ header = 2;}
else {
#ifdef debugPCM
Serial.println(F(" PCM Message fail address"));
#endif
header = 0; RESETheader_timer = 0;}}
// третий старт байт
if (header == 2 && Delay){
TIMER_DELAY ;
MessageRx_PCM[2]=K_LINE_PCM.read();
#ifdef debugPCM
printDebugRX (MessageRx_PCM[2]);
#endif
if (MessageRx_PCM[2]==PCM_address){ message_size = MessageRx_PCM[0]; prevRESETheader = curmillis;
if (MessageRx_PCM[0] !=0x80) {header = 4; bitWrite (message_size, 7 , 0);j=3;n=3;}
else {header = 3; j=4;n=4;}
if (message_size > bufsize) message_size = bufsize; crc = 0;}
else {header = 0;
#ifdef debugPCM
Serial.println(F("PCM Message fail address"));
#endif
RESETheader_timer = 0;}
}
// если размер сообщения указан в дополнительном байте (нулевой байт 0x80) читаем этот дополнительный байт:
if (header == 3 && Delay){
TIMER_DELAY ; prevRESETheader = curmillis;
MessageRx_PCM[3]=K_LINE_PCM.read();
#ifdef debugPCM
printDebugRX(MessageRx_PCM[3]);
#endif
message_size = MessageRx_PCM[3];
if (message_size > bufsize) message_size = bufsize;
crc = 0; header = 4;
}
// пишем тело сообщения
if (header == 4 && Delay && j< message_size+n+1) {
MessageRx_PCM[j] = K_LINE_PCM.read(); prevRESETheader = curmillis;
if (j<message_size+n) crc+= MessageRx_PCM[j]; // подсчёт КС
if (j==message_size+n) header = 5;
TIMER_DELAY ;
#ifdef debugPCM
printDebugRX(MessageRx_PCM[j]);
#endif
j++; }
}
// сообщение приняли, действуем
if (header == 5) {TIMER_DELAY ;
#ifdef debugPCM
Serial.println();
#endif
NOanswer_timer = 0; noanswers = 0; // сбрасываем таймер контроля неответов
for(byte i = 0; i<n; i++) crc+=MessageRx_PCM[i]; // прибавляем к контрольной сумме старт байты
// если контрольная сумма верна:
if ( crc == MessageRx_PCM[message_size+n])
{
#ifdef debugPCM
Serial.print (F("Received message is OK! Checksum is correct!")); Serial.print (F(" ")); Serial.println (millis()); // Если КС совпала, тут чёнибудь нужное делаем
printDebugRX_CSgood();
#endif
if (MessageRx_PCM[n]==0xC1 && MessageRx_PCM[n+1]==0x6B && MessageRx_PCM[n+2]==0x8F) {
if (currentPage!=3) {request = PID; RequestPeriod = 70;} else request = PRESENT, RequestPeriod = 4000; prevRequest = curmillis; // receive good INIT
}
else if (MessageRx_PCM[n]==0x58) Troublecodes (); // DTC
else if (MessageRx_PCM[n]==0x54 && MessageRx_PCM[n+1]==0xFF && MessageRx_PCM[n+2]==0x00){ request = PRESENT; RequestPeriod = 4000; prevRequest = curmillis;} // DTC are cleared
else if (MessageRx_PCM[n]==0x61 && MessageRx_PCM[n+1]==0x01) {dataVars() ; RequestPeriod = 70; prevRequest = curmillis; } // receive DataStream
}
// если контрольная сумма не совпала:
#ifdef debugPCM
else Serial.println("CRC fail!!!" );
#endif
message_size = 0; header=0; RESETheader_timer = 0; j=3; crc = 0;
}
// таймер ожидания байт (для успевания появления данных в буфере UART)
if (!Delay && curmillis - timerdelay > waitbyte_RX) Delay = 1;
// таймер сброса целостности сообщения (если данные оборвались посередине сообщения)
if (RESETheader_timer && curmillis - prevRESETheader > 200) {
#ifdef debugPCM
Serial.println(F("Message fail timeout"));
#endif
RESETheader_timer = 0; header = 0;}
// если нет ответа после запроса: +1 к счетчику неответов. Если накопилось 6 и более: делаем реинит.
if (request!=INIT && NOanswer_timer && curmillis - prev_NOanswer > RequestPeriod - RequestPeriod/10)
{
NOanswer_timer = 0; noanswers++;
if (noanswers>=6) { noanswers = 0; request = INIT; RequestPeriod = 3500;}
}
}// end receivePCM
void Troublecodes ()
{
if (MessageRx_PCM[n]==0x58 && MessageRx_PCM[n+1]==0x00){
myGLCD.clrScr();
drawscreen_three();
myGLCD.print("NO DTC", 165, 145);
}
// при получении сообщения о наличии ошибок DTC разберем сообщение выведем на экран ошибки
if (MessageRx_PCM[n]==0x58 && MessageRx_PCM[n+1]>0){
myGLCD.clrScr();
drawscreen_three();
for (int i=0; i<MessageRx_PCM[n+8-7]; i++ ) {
int y = i*35;
bool nolA=0; bool nolB =0;
if (!bitRead(MessageRx_PCM[n+11-7+(i*3)],6) && bitRead(MessageRx_PCM[n+11-7+(i*3)],7)){ myGLCD.setTextColor(GREEN, BLACK);
myGLCD.print(" -Passive-", 300, (75+y));} // если DTC пасивныый делаем цвет зеленый
if (bitRead(MessageRx_PCM[n+11-7+(i*3)],7) && bitRead(MessageRx_PCM[n+11-7+(i*3)],6)) { myGLCD.setTextColor(RED, BLACK);
myGLCD.print(" -Active-", 300, (75+y));} // если DTC активный, делаем цвет красный
myGLCD.print("ERROR ", 50, (75+y));
myGLCD.printNumI((i+1), 150, (75+y));
if (!bitRead(MessageRx_PCM[n+9-7+(i*3)],6) && !bitRead(MessageRx_PCM[n+9-7+(i*3)],7)) myGLCD.print(": P", 170, (75+y));
if (bitRead(MessageRx_PCM[n+9-7+(i*3)],6) && !bitRead(MessageRx_PCM[n+9-7+(i*3)],7)) myGLCD.print(": C", 170, (75+y));
if (!bitRead(MessageRx_PCM[n+9-7+(i*3)],6) && bitRead(MessageRx_PCM[n+9-7+(i*3)],7)) myGLCD.print(": B", 170, (75+y));
if (bitRead(MessageRx_PCM[n+9-7+(i*3)],6) && bitRead(MessageRx_PCM[n+9-7+(i*3)],7)) myGLCD.print(": U", 170, (75+y));
if (MessageRx_PCM[n+9-7+(i*3)]==0x00) {myGLCD.print("00", 230, (75+y)); nolA = 1;}
if (MessageRx_PCM[n+9-7+(i*3)]<=0x0F&&MessageRx_PCM[n+9-7+(i*3)]!=0) {myGLCD.print("0", 230, (75+y)); nolA = 1;}
if (nolA)myGLCD.print(String (MessageRx_PCM[n+9-7+(i*3)],HEX), 246, (75+y));
else myGLCD.print(String (MessageRx_PCM[n+9-7+(i*3)],HEX), 230, (75+y));
if (MessageRx_PCM[n+10-7+(i*3)]==0x00) {myGLCD.print("00", 262, (75+y)); nolB = 1;}
if (MessageRx_PCM[n+10-7+(i*3)]<=0x0F&&MessageRx_PCM[n+10-7+(i*3)]!=0) {myGLCD.print("0", 262, (75+y)); nolB = 1;}
if (nolB)myGLCD.print(String (MessageRx_PCM[n+10-7+(i*3)]),HEX, 278, (75+y));
else myGLCD.print(String (MessageRx_PCM[n+10-7+(i*3)],HEX), 262, (75+y));}}
request = PRESENT; RequestPeriod = 4000; prevRequest = curmillis;
}
void dataVars()
{
//Barom = MessageRx_PCM[39];
L100 = (float)LHor*100.0/(float)Speed;
LHor = (float)RPM* (float)InjQua*2.00/1000.0*60.00/1000.0/0.85;
MAF = ((MessageRx_PCM[n+22]*256)+MessageRx_PCM[n+23])/10;
BoostPres = ((MessageRx_PCM[n+24]*256)+MessageRx_PCM[n+25])/1000.0;
RPM = (MessageRx_PCM[n+35-7]*256)+MessageRx_PCM[n+36-7];
EGRmg = ((MessageRx_PCM[n+37-7]*256)+MessageRx_PCM[n+38-7])/10.0;
BoostPresCom = ((MessageRx_PCM[n+41-7]*256)+MessageRx_PCM[n+42-7])/1000.0;
Speed = ((MessageRx_PCM[n+47-7]*256)+MessageRx_PCM[n+48-7])/100;
DesaInjQua = ((MessageRx_PCM[n+53-7]*256)+MessageRx_PCM[n+54-7])/100.0;
InjQua = ((MessageRx_PCM[n+55-7]*256)+MessageRx_PCM[n+56-7])/100.0;
StaDaliv = ((MessageRx_PCM[n+57-7]*256)+MessageRx_PCM[n+58-7])/100.0;
PumpRPM = (MessageRx_PCM[n+59-7]*256)+MessageRx_PCM[n+60-7];
EGRPul = ((MessageRx_PCM[n+65-7]*256)+MessageRx_PCM[n+66-7])/100.0;
SolenPul = ((MessageRx_PCM[n+67-7]*256)+MessageRx_PCM[n+68-7])/100.0;
SolenPre = ((MessageRx_PCM[n+73-7]*256)+MessageRx_PCM[n+74-7])/100.0;
DesInj = ((MessageRx_PCM[n+75-7]*3)+(MessageRx_PCM[n+76-7])/100.0)+0.3;
ActInj = ((MessageRx_PCM[n+19-7]*3)+(MessageRx_PCM[n+20-7])/100.0)+0.3;
//TempAir = ((MessageRx_PCM[n+77-7]*26)-278)+MessageRx_PCM[n+78-7]/10.0;
//Temp = ((MessageRx_PCM[n+17-7]*26)-278)+MessageRx_PCM[n+18-7]/10.0;
//TempOil = ((MessageRx_PCM[n+21-7]*26)-278)+MessageRx_PCM[n+22-7]/10.0;
//TempFuel = ((MessageRx_PCM[n+61-7]*26)-278)+MessageRx_PCM[n+62-7]/10.0;
//ниже идут расчетные формулы более точные чем те что закоментированы выше
int A = 0;
if (MessageRx_PCM[n+77-7]<=0x0A) A = 277;
if (MessageRx_PCM[n+77-7]==0x0B || MessageRx_PCM[n+77-7]==0x0C) A = 278;
if (MessageRx_PCM[n+77-7]>=0x0D) A = 279;
double B = MessageRx_PCM[n+78-7]/10.0;
double cel , drob ;
drob = modf(B, &cel);
if (drob>0.6) cel++;
TempAir = ((MessageRx_PCM[n+77-7]*26)-A)+cel;
if (MessageRx_PCM[n+17-7]<=0x0A) A = 277;
if (MessageRx_PCM[n+17-7]==0x0B || MessageRx_PCM[n+17-7]==0x0C) A = 278;
if (MessageRx_PCM[n+17-7]>=0x0D) A = 279;
B = MessageRx_PCM[n+18-7]/10.0;
drob = modf(B, &cel);
if (drob>0.6) cel++;
Temp = ((MessageRx_PCM[n+17-7]*26)-A)+cel;
if (MessageRx_PCM[n+21-7]<=0x0A) A = 277;
if (MessageRx_PCM[n+21-7]==0x0B || MessageRx_PCM[n+21-7]==0x0C) A = 278;
if (MessageRx_PCM[n+21-7]>=0x0D) A = 279;
B = MessageRx_PCM[n+22-7]/10.0;
drob = modf(B, &cel);
if (drob>0.6) cel++;
TempOil = ((MessageRx_PCM[n+21-7]*26)-A)+cel;
if (MessageRx_PCM[n+61-7]<=0x0A) A = 277;
if (MessageRx_PCM[n+61-7]==0x0B || MessageRx_PCM[n+61-7]==0x0C) A = 278;
if (MessageRx_PCM[n+61-7]>=0x0D) A = 279;
B = MessageRx_PCM[n+62-7]/10.0;
drob = modf(B, &cel);
if (drob>0.6) cel++;
TempFuel = ((MessageRx_PCM[n+61-7]*26)-A)+cel;
//----------------------------------------------------------
//страниц HOME
//----------------------------------------------------------
//myGLCD.setBackColor(RED);
myGLCD.setTextColor(WHITE, BLACK);
//myGLCD.setBackColor(RED);
if ((Speed != Speed_last) || reNew) {myGLCD.printNumI(Speed, 350, 7, 4); Speed_last=Speed;}
if (currentPage == '0') {
if ((LHor != LHor_last) || reNew) {myGLCD.printNumF(LHor, 1, 60, 40, '.',5); LHor_last=LHor;}
if ((L100 != L100_last) || reNew) {myGLCD.printNumF(L100, 1, 210, 40,'.',5 ); L100_last=L100;}
if ((L100M != L100M_last) || reNew) {myGLCD.printNumF(L100M, 1, 60, 75,'.',5 ); L100M_last=L100M;}
if ((L100SR_TFT != L100SR_TFT_last) || reNew) {myGLCD.printNumF(L100SR_TFT, 1, 210, 75,'.',5 ); L100SR_TFT_last=L100SR_TFT;}
if ((kmREFUELING != kmREFUELING_last) || reNew) {myGLCD.printNumI(kmREFUELING, 60, 110,5 ); kmREFUELING_last=kmREFUELING;}
//if (Fuel<53)
if ((Fuel != Fuel_last) || reNew) {myGLCD.printNumF(Fuel, 1, 210, 110,'.',5); Fuel_last=Fuel;}
//else myGLCD.print("MAX", 210, 110);
if ((kmTrip != kmTrip_last) || reNew) {myGLCD.printNumF(kmTrip, 1, 60, 145,'.',5); kmTrip_last=kmTrip;}
if ((FuelTrip != FuelTrip_last) || reNew) {myGLCD.printNumF(FuelTrip, 1, 210, 145,'.',5); FuelTrip_last=FuelTrip;}
if ((PumpRPM != PumpRPM_last) || reNew) {myGLCD.printNumI(PumpRPM, 210, 180,5); PumpRPM_last=PumpRPM;}
if ((RPM != RPM_last) || reNew) {myGLCD.printNumI(RPM, 210, 215,5); RPM_last=RPM;}
if ((Fuel2 != Fuel2_last) || reNew) {myGLCD.printNumF(Fuel2, 1, 0, 215,'.',5); Fuel2_last=Fuel2;}
if ((Temp != Temp_last) || reNew) {myGLCD.printNumI(Temp, 415, 40, 3); Temp_last=Temp;}
if ((TempOil != TempOil_last) || reNew) {myGLCD.printNumI(TempOil, 415, 75, 3); TempOil_last=TempOil;}
if ((TempFuel != TempFuel_last) || reNew) {myGLCD.printNumI(TempFuel, 415, 110,3); TempFuel_last=TempFuel;}
//myGLCD.printNumI(sensors.getTempCByIndex(0), 415, 145 , 3);
if ((t != t_last) || reNew) {myGLCD.printNumI(t, 415, 180, 3); t_last=t;}
if ((TempAir != TempAir_last) || reNew) {myGLCD.printNumI(TempAir, 415, 215, 3); TempAir_last=TempAir;}
}
//----------------------------------------------------------
//страниц INF1
//----------------------------------------------------------
if (currentPage == '1') {
if ((StaDaliv != StaDaliv_last) || reNew) {myGLCD.printNumF(StaDaliv,1, 360, 40,'.', 3); StaDaliv_last=StaDaliv;}
if ((DesInj != DesInj_last) || reNew) {myGLCD.printNumF(DesInj,1, 395, 75, '.', 4); DesInj_last=DesInj;}
if ((ActInj != ActInj_last) || reNew) {myGLCD.printNumF(ActInj,1, 395, 110,'.', 4); ActInj_last=ActInj;}
if ((DesaInjQua != DesaInjQua_last) || reNew) {myGLCD.printNumF(DesaInjQua,1, 395, 145,'.', 4);DesaInjQua_last=DesaInjQua;}
if ((InjQua != InjQua_last) || reNew) {myGLCD.printNumF(InjQua,1, 395, 180,'.', 4); InjQua_last=InjQua;}
if ((MAF != MAF_last) || reNew) {myGLCD.printNumI(MAF, 170, 215, 4); MAF_last=MAF;}
if ((h != h_last) || reNew) {myGLCD.printNumF(h, 1, 418, 215); h_last=h;}
}
//----------------------------------------------------------
//страниц INF2
//----------------------------------------------------------
if (currentPage == '2') {
if ((BoostPres != BoostPres_last) || reNew) {myGLCD.printNumF(BoostPres,1, 395, 40,'.', 4); BoostPres_last=BoostPres;}
if ((BoostPresCom != BoostPresCom_last) || reNew) {myGLCD.printNumF(BoostPresCom,1, 395, 75,'.', 4); BoostPresCom_last=BoostPresCom;}
if ((EGRmg != EGRmg_last) || reNew) {myGLCD.printNumI(EGRmg, 395, 110, 4); EGRmg_last=EGRmg;}
if ((EGRPul != EGRPul_last) || reNew) {myGLCD.printNumF(EGRPul,1, 410, 145,'.', 3); EGRPul_last=EGRPul;}
if ((SolenPul != SolenPul_last) || reNew) {myGLCD.printNumF(SolenPul, 1, 395, 180,'.', 4); SolenPul_last=SolenPul;}
if ((SolenPre != SolenPre_last) || reNew) {myGLCD.printNumF(SolenPre, 0, 410, 215,'.', 3); SolenPre_last=SolenPre;}
}
reNew = 0;
}
void sendMessagePCM(const byte &command)
{
#ifdef debugPCM
Serial.print (F("Send request ")); Serial.print (textRequest[command]); Serial.print (F(" to PCM ")); Serial.println (millis());
#endif
if (command != INIT) {NOanswer_timer = 1; prev_NOanswer = curmillis;} //т.к. сейчас будем делать запрос, то запускаем таймер контроля неответов
byte size = PCM_Message_TX[command][0];
const byte siZe = size+4;
byte Mes[siZe];
byte Checksum = 0;
for(byte i=0; i<siZe; i++) {
if (i==0) {Mes[i]=size; bitWrite(Mes[i], 7 , 1);}
if (i==1) Mes[i] = PCM_address;
if (i==2) Mes[i] = DIAG_address;
if (i==3) {for (byte t=1; t<size+1; t++ ) {
Mes[i]=PCM_Message_TX [command][t];
Checksum+=Mes[i] ;
K_LINE_PCM.write (Mes[i]);
if (command == INIT) delay (5); else delay (delaybyte_TX);
K_LINE_PCM.read();
i++;}}
if (i!=siZe-1) Checksum+=Mes[i];
else Mes[i] = Checksum;
K_LINE_PCM.write (Mes[i]);
if (command == INIT) delay (5); else delay (delaybyte_TX);
K_LINE_PCM.read();
}
}// end sendMessagePCM
#if defined debugPCM or debugGAUGE
void printDebugRX (const byte &inbyte) {if (inbyte<=15) Serial.print(F("0")); Serial.print (inbyte, HEX); Serial.print (F(" "));}
#endif
#ifdef debugPCM
void printDebugRX_CSgood(){
if (MessageRx_PCM[n]==0xC1 && MessageRx_PCM[n+1]==0x6B && MessageRx_PCM[n+2]==0x8F) {Serial.println (F(" Initialization OK!!!!")); }
else if (MessageRx_PCM[n]==0x58 && MessageRx_PCM[n+1]==0x00) {Serial.println (F(" NO DTC "));}
else if (MessageRx_PCM[n]==0x58 && MessageRx_PCM[n+1] >0x00) {Serial.println (F(" DTC is found!"));}
else if (MessageRx_PCM[n]==0x54 && MessageRx_PCM[n+1]==0xFF && MessageRx_PCM[n+2]==0x00){Serial.println (F(" DTC CLEARED "));}
else if (MessageRx_PCM[n]==0x61 && MessageRx_PCM[n+1]==0x01) {Serial.println (F(" Receive PCM DATAstream"));}}
#endif
void Menu () {
TouchHOME();
if (currentPage == '0') {
TouchINF1();
TouchINF2();
TouchCHECK(); }
if (currentPage == '1') {
TouchINF2();
TouchCHECK(); }
if (currentPage == '2') {
TouchINF1();
TouchCHECK(); }
if (currentPage == '3') {
TouchREAD();
TouchERASE(); }}
void drawHomeScreen() {
reNew = 1;
line() ;
Watch ();
myGLCD.print("/", 115, 7);
myGLCD.print("/", 160, 7);
myGLCD.setTextColor(RED, BLACK); // цвет линии и текста красный
myGLCD.drawLine(295,35,295,248); // линия вертикальная
myGLCD.drawLine(145,35,145,178); // линия вертикальная
myGLCD.drawLine(80,178,80,247); // линия вертикальная
myGLCD.print("L/H", 10, 40);
myGLCD.print("L/A", 148, 40);
myGLCD.print("L/V", 10, 75);
myGLCD.print("L/M", 148, 75);
myGLCD.print("D/K", 10, 110);
myGLCD.print("D/L", 148, 110);
myGLCD.print("V/K", 10, 145);
myGLCD.print("V/L", 148, 145);
myGLCD.print("PUMP RPM", 82, 180);
myGLCD.print("ENGI RPM", 82, 215);
myGLCD.print("D/La", 10, 180);
myGLCD.print("Motor C", 300, 40);
myGLCD.print("OIL C", 300, 75);
myGLCD.print("FUEL C", 300, 110);
myGLCD.print("INTER C", 300, 145);
myGLCD.print("EXTER C", 300, 180);
myGLCD.print("INTAIR C", 300, 215);
//myGLCD.setTextColor(RED);
myGLCD.drawRoundRect (15, 255, 145, 310);
myGLCD.print("INF 1", 55, 270);
myGLCD.drawRoundRect (175, 255, 305, 310);
myGLCD.print("INF 2", 215, 270);
myGLCD.drawRoundRect (335, 255, 465, 310);
myGLCD.print("CHECK", 365, 270);
myGLCD.drawRoundRect (1, 1, 77, 37);
myGLCD.print("HOME", 10, 7);
myGLCD.print("Km/h", 410, 7);
}
//-------------------------------------------------
void drawscreen_one() {
reNew = 1;
line() ;
Watch ();
myGLCD.print("/", 115, 7);
myGLCD.print("/", 160, 7);
myGLCD.setTextColor(RED, BLACK); // цвет линии и текста красный
myGLCD.print("Start of Delivery *CA:", 10, 40);
myGLCD.print("Desir inject Start *CA:", 10, 75);
myGLCD.print("Actua Inject Start *CA:", 10, 110);
myGLCD.print("Desir Inject Quan mg/s:", 10, 145);
myGLCD.print("Actu Inject Quant mg/s:", 10, 180);
myGLCD.print("MAF mg/s:", 10, 215);
myGLCD.print("Humedad %:", 255, 215);
//myGLCD.setTextColor(RED);
myGLCD.drawRoundRect (175, 255, 305, 310);
myGLCD.print("INF 2", 215, 270);
myGLCD.drawRoundRect (335, 255, 465, 310);
myGLCD.print("CHECK", 365, 270);
myGLCD.drawRoundRect (1, 1, 77, 37);
myGLCD.print("HOME", 10, 7);
myGLCD.print("Km/h", 410, 7);
}
//-------------------------------------------------
void drawscreen_two() {
reNew = 1;
line() ;
Watch ();
myGLCD.print("/", 115, 7);
myGLCD.print("/", 160, 7);
myGLCD.setTextColor(RED, BLACK); // цвет линии и текста красный
myGLCD.print("Boost Press Bar:", 10, 40);
myGLCD.print("Boost Press Com Bar:", 10, 75);
myGLCD.print("EGR command mg/s:", 10, 110);
myGLCD.print("EGR Pulse Ratio %:", 10, 145);
myGLCD.print("Solenoide Pulse %:", 10, 180);
myGLCD.print("Solenoide Boost %:", 10, 215);
//myGLCD.setColor(RED);
myGLCD.drawRoundRect (15, 255, 145, 310);
myGLCD.print("INF 1", 55, 270);
myGLCD.drawRoundRect (335, 255, 465, 310);
myGLCD.print("CHECK", 365, 270);
myGLCD.drawRoundRect (1, 1, 77, 37);
myGLCD.print("HOME", 10, 7);
myGLCD.print("Km/h", 410, 7);
}
//----------------------------------------------------------------------------
void drawscreen_three() {
reNew = 1;
Watch ();
myGLCD.print("/", 115, 7);
myGLCD.print("/", 160, 7);
myGLCD.setTextColor(RED, BLACK); // цвет линии красный
myGLCD.drawLine(1,35,479,35); // линия горизонтальная
myGLCD.drawLine(1,248,479,248); // линия горизонтальная
//myGLCD.setTextColor(RED);
myGLCD.drawRoundRect (15, 255, 145, 310);
myGLCD.print("ERASE", 55, 270);
myGLCD.drawRoundRect (335, 255, 465, 310);
myGLCD.print("READ", 365, 270);
myGLCD.drawRoundRect (1, 1, 77, 37);
myGLCD.print("HOME", 10, 5);
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//кнопки тач . координаты и переходы
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void TouchHOME(){
TSPoint p = ts.getPoint();
pinMode(XM, OUTPUT);
pinMode(YP, OUTPUT);
if (p.z > 10 && p.z < 1000)
{if (p.x > 140 && p.x < 320 && p.y > 140 && p.y < 260 && p.z > MINPRESSURE && p.z < MAXPRESSURE)
{ myGLCD.drawRoundRect (1, 1, 77, 37);
currentPage = '0';
request = PID; RequestPeriod = 10; prevRequest = curmillis; // на PCM в этом окне посылается запрос текущих параметров
myGLCD.clrScr();
drawHomeScreen();
x = 0;
y = 0;
p.z = 0;}}}
void TouchINF1(){
TSPoint p = ts.getPoint();
pinMode(XM, OUTPUT);
pinMode(YP, OUTPUT);
if (p.z > 10 && p.z < 1000)
{
if (p.x > 150 && p.x < 450 && p.y > 770 && p.y < 890 && p.z > MINPRESSURE && p.z < MAXPRESSURE)
{ myGLCD.drawRoundRect (15, 255, 145, 310);
currentPage = '1';
request = PID; RequestPeriod = 10; prevRequest = curmillis; // на PCM в этом окне посылается запрос текущих параметров
myGLCD.clrScr();
drawscreen_one();
x = 0;
y = 0;
p.z = 0;}}}
void TouchINF2(){
TSPoint p = ts.getPoint();
pinMode(XM, OUTPUT);
pinMode(YP, OUTPUT);
if (p.z > 10 && p.z < 1000)
{
if (p.x > 450 && p.x < 680 && p.y > 770 && p.y < 890 && p.z > MINPRESSURE && p.z < MAXPRESSURE)
{ myGLCD.drawRoundRect (175, 255, 305, 310);
currentPage = '2';
request = PID; RequestPeriod = 600; prevRequest = curmillis; // на PCM в этом окне посылается запрос текущих параметров
myGLCD.clrScr();
drawscreen_two();
x = 0;
y = 0;
p.z = 0;}}}
void TouchCHECK(){
TSPoint p = ts.getPoint();
pinMode(XM, OUTPUT);
pinMode(YP, OUTPUT);
if (p.z > 10 && p.z < 1000)
{
if (p.x > 690 && p.x < 950 && p.y > 770 && p.y < 890 && p.z > MINPRESSURE && p.z < MAXPRESSURE)
{ myGLCD.drawRoundRect (335, 255, 465, 310);
currentPage = '3';
// request = DTCREAD; RequestPeriod = 10; prevRequest = curmillis; // на PCM в этом окне посылается запрос чтения ошибок
myGLCD.clrScr();
drawscreen_three();
x = 0;
y = 0;
p.z = 0;}}}
void TouchREAD(){
TSPoint p = ts.getPoint();
pinMode(XM, OUTPUT);
pinMode(YP, OUTPUT);
if (p.z > 10 && p.z < 1000)
{
if (p.x > 690 && p.x < 950 && p.y > 770 && p.y < 890 && p.z > MINPRESSURE && p.z < MAXPRESSURE)
{ myGLCD.drawRoundRect (335, 255, 465, 310);
request = DTCREAD; RequestPeriod = 300; prevRequest = curmillis; // на PCM при нажатии этой кнопки посылается запрос чтения ошибок
x = 0;
y = 0;
p.z = 0;}}}
void TouchERASE(){
TSPoint p = ts.getPoint();
pinMode(XM, OUTPUT);
pinMode(YP, OUTPUT);
if (p.z > 10 && p.z < 1000)
{
if (p.x > 150 && p.x < 450 && p.y > 770 && p.y < 890 && p.z > MINPRESSURE && p.z < MAXPRESSURE)
{myGLCD.drawRoundRect (15, 255, 145, 310);
request = DTCERASE; RequestPeriod = 300; prevRequest = curmillis; // на PCM при нажатии этой кнопки посылается запрос удаления ошибок
x = 0;
y = 0;
p.z = 0;}}}
////////////////////////////////////////////////////////////////////////////////////////
//прорисовка линий
///////////////////////////////////////////////////////////////////////////////////////
void line() {
//myGLCD.setTextColor(RED); // цвет линии красный
myGLCD.drawLine(1,35,479,35); // линия горизонтальная
myGLCD.drawLine(1,73,479,73); // линия горизонтальная
myGLCD.drawLine(1,108,479,108); // линия горизонтальная
myGLCD.drawLine(1,143,479,143); // линия горизонтальная
myGLCD.drawLine(1,178,479,178); // линия горизонтальная
myGLCD.drawLine(1,212,479,212); // линия горизонтальная
myGLCD.drawLine(1,248,479,248); // линия горизонтальная
}
void Watch (){
DateTime now = rtc.now();
int minut = now.minute();
int hour = now.hour();
int mon = now.month();
int date = now.day();
int Year = now.year();
static int minut_last;
static int hour_last;
static int mon_last;
static int date_last;
static int Year_last;
myGLCD.setTextColor(WHITE, BLACK); //белый цвет цифры
if (date != date_last || reNew){ myGLCD.printNumI(date, 85, 7, 2, '0'); date_last = date; }
if (mon!=mon_last || reNew){myGLCD.printNumI(date, 130, 7, 2, '0'); mon_last = mon; }
if (Year!=Year_last || reNew) { myGLCD.printNumI(Year, 175, 7); Year_last = Year; }
if (hour!=hour_last || reNew){ myGLCD.printNumI(date, 255, 7, 2, '0'); hour_last = hour; }
if (minut!=minut_last || reNew ){ myGLCD.printNumI(date, 300, 7, 2, '0'); minut_last = minut; }
}
:) от я идиот слепой. Все норм. на счет мест ты говорил что оборот 5 мест а не 4 . так вот заметил например на скорости и на других данных, если ставить четко сколько места то первую цифру не дотирает с краю с лева остается не дотертортость. если поставить на одно метсо большо то все дотирает. проверил на оборотах, по этому одно метсо нужно лишнее. Все ты добил эту библиотеку, теперь дело за Максом, общение с панелью. 816 пронесло потому что была сделана Максом. ЭХ красиво работает.
принял ща ковырну. помогло +5 , отлично ща подправлю все. ща буду боротся с цветом линий и рамок кнопок. со словами не проблем есть достаточно места. поборол двоеточие поставил как в моем старом скетче, работет четко if (millis() - prevDvoet > 500) { if (!Dvoet) {myGLCD.print(":", 290, 5);} else {myGLCD.print(" ", 290, 5);} prevDvoet = millis(); Dvoet=!Dvoet;}
вот полностью подправленый скетч. для Макса, для продолжения работы над панелью. Командир тебе ОГРОМНОЕ СПАСИБО, за терпение и труд.
#include <Adafruit_GFX.h>
#include <MCUFRIEND_kbv.h>
#include <UTFTGLUE.h>//use GLUE class and constructor
#include "TouchScreen.h"
#include <stdint.h>
#include <SPI.h>
#include <EEPROM.h>
//MCUFRIEND_kbv tft;
#include "Fonts/Chosence_Bold16pt7b.h";
#define MINPRESSURE 200
#define MAXPRESSURE 1000
//pin 20 SCL , 21 SDA датчик реального времени
#include <Wire.h>
#include "RTClib.h"
RTC_DS3231 rtc;
UTFTGLUE myGLCD(0x1581,A2,A1,A3,A4,A0); //all dummy args
const int XP = 6, XM = A2, YP = A1, YM = 7;
const int TS_LEFT = 136, TS_RT = 907, TS_TOP = 139, TS_BOT = 942;
TouchScreen ts = TouchScreen(XP, YP, XM, YM, 300);
uint16_t ID;
int x, y;
char currentPage;
float h; int h_last = 1;
float t; int t_last = 1;
bool Dvoet = 0;
bool reNew = 0;
#define BLACK 0x0000
#define WHITE 0xFFFF
#define RED 0xF800
#define GREEN 0x07E0
#include <SoftwareSerial.h>
#define TX_PCM 13
SoftwareSerial K_LINE_PCM (12, TX_PCM); //RХ,TХ
#define PCM_address 0x11 // адрес PCM
#define DIAG_address 0xF1 // адрес диагностики
#define debugPCM // раскоментировать эту строку для отладки в Serial порту обмена с PCM
//#define debugGAUGE // раскоментировать эту строку для отладки в Serial порту обмена co щитком приборов
uint32_t curmillis = 0; // снимок текущего времени
uint32_t prevRequest = 0; // таймер периодических запосов на PCM
uint16_t RequestPeriod = 3500; // периодичность запросов на PCM
uint32_t prevRESETheader=0; // таймер сброса сообщения, если данные оборвались посередине сообщения
bool RESETheader_timer; // таймер сброса сообщения, если данные оборвались посередине сообщения
uint32_t prev_NOanswer=0; // таймер контроля неответов от ЭБУ после подачи запросов
bool NOanswer_timer = 0; // таймер контроля неответов от ЭБУ после подачи запросов
byte noanswers = 0; // количество подряд неответов от ЭБУ
uint32_t timerdelay = 0; // таймер ожидания байт (для успевания появления данных в буфере UART)
bool Delay = 0; // таймер ожидания байт (для успевания появления данных в буфере UART)
byte waitbyte_RX = 1; // задержка, мс для успевания появления данных в буфере RX
// (подрегулировать в зависимости от уровня жизнидеятельности на Марсе)
#define TIMER_DELAY Delay = 0; timerdelay = curmillis // включение этого таймера
byte delaybyte_TX = 1; // задержка между отправкой байт в запросах, мс
byte header = 0; // состояние заголовка
byte message_size = 0; // размер тела сообщения
byte j = 3; // инкремент
byte n = 3; // количество старт байт
const byte bufsize = 150; // размер буфера принятого сообщения
byte MessageRx_PCM [bufsize] = {0}; // буфер принятого сообщения
byte crc =0; // байт контрольной суммы
// возможные варианты запросов на ЭБУ:
enum REQUEST {
INIT,
PID,
DTCERASE,
DTCREAD,
PRESENT,
};
// текстовки запросов для отладки
char* textRequest[] = {
"INIT",
"PID_2101",
"DTC_ERASE",
"DTC_READ",
"PRESENT",
} ;
// сами запросы
byte PCM_Message_TX[][5] = {
{1, 0x81, 0,0,0}, // запрос инициализации
{2, 0x21,0x01, 0,0}, // запрос пид 2101
{3, 0x14,0xFF,0x00, 0}, // запрос на стирание ошибок
{4, 0x18,0x00,0xFF,0x00 }, // запрос на чтение ошибок
{1, 0x3E, 0,0,0}, // запрос присутствия
};
byte request = INIT; // переменная, показывающая какой запрос будем делать
//-------------------------------------------переменные бортовика
float L100M = 0; float L100M_last = 1; //расход на 100 км измеренный за поездку
float L100 = 0; float L100_last = 1; //мгновенный расход литров на 100км
float LHor = 0; float LHor_last = 1; //мгновенный расход топлива литров в час
float L100SR = 0; //расход литров на 100км измеренный раз в интервал kmL
float L100SR_TFT = 0; float L100SR_TFT_last = 1; // самый средний из расходов на 100км, он выводится на экран
int L100_Eeprom[11]= {10,10,10,10,10,10,10,10,10,10,10};
int FuelZamer[10]= {0}; // массив для измерения уровня (количества) топлива
int ZamerNumber = 0; // номер замера уровня (количества) топлива
int n_eeprom = 0; // текущий адрес ячейки еепром для записи расхода
int MAF = 0; int MAF_last = 1; //26,27 байты Sensor de flujo de aire en masa
float BoostPres = 0; float BoostPres_last = 1; //28,29 байты Presión de refuerzo
int RPM = 0; int RPM_last = 1; //32,33 байты Velocidad del motor
int EGRmg = 0; int EGRmg_last = 1; //34,35 байты Comando EGR (Comando de recirculación de gases de escape)
float BoostPresCom = 0; float BoostPresCom_last = 1; //38,39 байты Comando de presión de refuerzo
int Speed = 0; int Speed_last = 1; //44,45 байты Velocidad del vehículo
float DesaInjQua = 0; float DesaInjQua_last = 1; //50,51 байты Cantidad de inyección deseada
float InjQua = 0; float InjQua_last = 1; //52,53 байты Cantidad de la inyección
float StaDaliv = 0; float StaDaliv_last = 1; //54,55 байты Inicio de la entrega
int PumpRPM = 0; int PumpRPM_last = 1; //56,57 байты Velocidad de la bomba
float EGRPul = 0; float EGRPul_last = 1; //62,63 байты Relación de impulsos EGR (recirculación de gases de escape
float SolenPul = 0; float SolenPul_last = 1; //64,65 байты Velocidad de solenoide de control de nivel de remolino Relación de impulsos
float SolenPre = 0; float SolenPre_last = 1; //70,71 байты Relación de impulsos Presión Electroválvula de presión
float DesInj = 0; float DesInj_last = 1; //72,73 байты Inyección deseada Inicio
float ActInj = 0; float ActInj_last = 1; //16,17 байты Inicio de la inyección real
int TempAir = 0; int TempAir_last = 1; //74,75 байты Temperatura del aire de admisión
int Temp = 0; int Temp_last = 1; //14,15 байты Temperatura del refrigerante
int TempOil = 0; int TempOil_last = 1; //18,19 байты Temperatura del aceite del motor
int TempFuel = 0; int TempFuel_last = 1; //58,59 байты Temperatura del combustible
//все что касается топлива
float Fuel = 0; //остаток топлива
float Fuel2 = 0; float Fuel2_last = 1; //остаток мгновенного топлива байт 16 , датчика в баке
int FuelIGN = 0; // количество топлвива в баке на момент включения зажигания
int Fuel_last = 0; // для формул
bool flagFuelIGN = 0; // флаг записан ли остаток топлива в момент вкл. зажигания
float FuelTrip = 0; float FuelTrip_last = 1; // количество литров топлива, израсходованное за один цикл включения зажигания
//все что касается километража
float kmAge = 0; //пробег, полученный со щитка приборов
int kmAgeIGN = 0; //пробег который был в момент включения зажигания
int kmAge_last = 0; // для формул
bool flagkmAgeIGN = 0; //флаг записан ли пробег в момент вкл. зажигания
float kmTrip = 0; float kmTrip_last = 1; //пробег за один цикл включения зажигания
int kmL = 10; // интервал, через который будет происходить обновление среднего расхода на 100км
int km = 0; // переменная для расчетов
int kmeeprom = 10; // интервал, через который будет происходить подсчет среднеарифмитического расхода L100SR_TFT
int kmTFT = 0; // переменная для расчетов периодического подсчета среднеарифмитического расхода топлива L100SR_TFT
int kmREFUELING = 0; int kmREFUELING_last = 1; // пробег до заправки на остатке топлива
unsigned long prevWatch = 0;
unsigned long prevDvoet = 0;
unsigned long prevData = 0;
void setup() {
uint16_t ID = myGLCD.readID();
if (ID == 0xD3D3) ID = 0x1581; // write-only shield
myGLCD.begin(ID);
myGLCD.InitLCD(3);
myGLCD.clrScr();
myGLCD.setFont(&Chosence_Bold16pt7b);
//myGLCD.fillScreen(WHITE);
//myGLCD.setTextColor(WHITE, BLACK);
//myGLCD.setBackColor(BLACK);
Wire.begin();
rtc.begin();
//загрузка стартовой страницы
currentPage = '0';
drawHomeScreen();
//подсчет среднеарифметического усредненного расхода
for (int i = 0; i < 11; i++) L100_Eeprom [i]= EEPROM.read(i);
for (int i = 0; i < 11; i++) L100SR_TFT = L100SR_TFT + L100_Eeprom [i];
L100SR_TFT = (float)L100SR_TFT/110.0;
if (L100SR_TFT<0) L100SR_TFT = 0;
if (L100SR_TFT>99) L100SR_TFT = 99;
// строка ниже используется для настройки даты и времени часов
// раскоментировать, выставить времая и дату, залить в ардуино. в скетче закоментировать
// обратно и залить еще раз, иначе каждый раз будет по новой выствлятся это же время и дата
// (год, месяц, день, часы, минуты, секунды)
//rtc.adjust(DateTime(2019, 7, 2, 10, 48, 0));
#if defined debugPCM or debugGAUGE
Serial.begin(115200);
#endif
K_LINE_PCM.begin(10400);
pinMode(TX_PCM, OUTPUT);
}
void loop()
{
curmillis = millis(); // снимок текущего времени
if (curmillis - prevRequest > RequestPeriod && header == 0 )
{
if (request == INIT) fastinit(); // при необходимости делаем переподключение к PCM
else {sendMessagePCM(request); // отправляем на PCM текущий запрос
if (request == PID) RequestPeriod = 600;
if (request == DTCERASE || request == DTCREAD) RequestPeriod = 2500;}
prevRequest = curmillis;
}
receivePCM (); // приём сообщений от PCM
if (header == 0) Menu ();
if (curmillis - prevWatch > 3000) { Watch (); prevWatch = curmillis;}
//if (curmillis - prevDvoet > 500) { if (!Dvoet) {myGLCD.setTextColor(WHITE); } else {myGLCD.setTextColor(BLACK); } myGLCD.print(":", 290, 5); prevDvoet = curmillis; Dvoet=!Dvoet;}
if (millis() - prevDvoet > 500) { if (!Dvoet) {myGLCD.print(":", 290, 5);} else {myGLCD.print(" ", 290, 5);} prevDvoet = millis(); Dvoet=!Dvoet;}
}// end loop
void fastinit() {
digitalWrite (TX_PCM, HIGH); // bus idle
delay(1500);
digitalWrite (TX_PCM, LOW); // first part fastinit (25 ms LOW)
delay(25);
digitalWrite (TX_PCM, HIGH); // second part fastinit (25 ms HIGH)
delay(25);
K_LINE_PCM.begin(10400);
sendMessagePCM(INIT); // send start communication message
}
void receivePCM () {
if (K_LINE_PCM.available() ){
// первый старт байт
if (header == 0 && Delay){TIMER_DELAY ; MessageRx_PCM[0]=K_LINE_PCM.read();
if (MessageRx_PCM[0]!=0xFF && bitRead (MessageRx_PCM[0],7)){header = 1; RESETheader_timer = 1; prevRESETheader = curmillis;
#ifdef debugPCM
Serial.print (F("Receive PCM: ")); printDebugRX(MessageRx_PCM[0]);
#endif
}
}
// второй старт байт
if (header == 1 && Delay){TIMER_DELAY ; MessageRx_PCM[1]=K_LINE_PCM.read();
#ifdef debugPCM
printDebugRX (MessageRx_PCM[1]);
#endif
if (MessageRx_PCM[1]==DIAG_address){ header = 2;}
else {
#ifdef debugPCM
Serial.println(F(" PCM Message fail address"));
#endif
header = 0; RESETheader_timer = 0;}}
// третий старт байт
if (header == 2 && Delay){
TIMER_DELAY ;
MessageRx_PCM[2]=K_LINE_PCM.read();
#ifdef debugPCM
printDebugRX (MessageRx_PCM[2]);
#endif
if (MessageRx_PCM[2]==PCM_address){ message_size = MessageRx_PCM[0]; prevRESETheader = curmillis;
if (MessageRx_PCM[0] !=0x80) {header = 4; bitWrite (message_size, 7 , 0);j=3;n=3;}
else {header = 3; j=4;n=4;}
if (message_size > bufsize) message_size = bufsize; crc = 0;}
else {header = 0;
#ifdef debugPCM
Serial.println(F("PCM Message fail address"));
#endif
RESETheader_timer = 0;}
}
// если размер сообщения указан в дополнительном байте (нулевой байт 0x80) читаем этот дополнительный байт:
if (header == 3 && Delay){
TIMER_DELAY ; prevRESETheader = curmillis;
MessageRx_PCM[3]=K_LINE_PCM.read();
#ifdef debugPCM
printDebugRX(MessageRx_PCM[3]);
#endif
message_size = MessageRx_PCM[3];
if (message_size > bufsize) message_size = bufsize;
crc = 0; header = 4;
}
// пишем тело сообщения
if (header == 4 && Delay && j< message_size+n+1) {
MessageRx_PCM[j] = K_LINE_PCM.read(); prevRESETheader = curmillis;
if (j<message_size+n) crc+= MessageRx_PCM[j]; // подсчёт КС
if (j==message_size+n) header = 5;
TIMER_DELAY ;
#ifdef debugPCM
printDebugRX(MessageRx_PCM[j]);
#endif
j++; }
}
// сообщение приняли, действуем
if (header == 5) {TIMER_DELAY ;
#ifdef debugPCM
Serial.println();
#endif
NOanswer_timer = 0; noanswers = 0; // сбрасываем таймер контроля неответов
for(byte i = 0; i<n; i++) crc+=MessageRx_PCM[i]; // прибавляем к контрольной сумме старт байты
// если контрольная сумма верна:
if ( crc == MessageRx_PCM[message_size+n])
{
#ifdef debugPCM
Serial.print (F("Received message is OK! Checksum is correct!")); Serial.print (F(" ")); Serial.println (millis()); // Если КС совпала, тут чёнибудь нужное делаем
printDebugRX_CSgood();
#endif
if (MessageRx_PCM[n]==0xC1 && MessageRx_PCM[n+1]==0x6B && MessageRx_PCM[n+2]==0x8F) {
if (currentPage!=3) {request = PID; RequestPeriod = 70;} else request = PRESENT, RequestPeriod = 4000; prevRequest = curmillis; // receive good INIT
}
else if (MessageRx_PCM[n]==0x58) Troublecodes (); // DTC
else if (MessageRx_PCM[n]==0x54 && MessageRx_PCM[n+1]==0xFF && MessageRx_PCM[n+2]==0x00){ request = PRESENT; RequestPeriod = 4000; prevRequest = curmillis;} // DTC are cleared
else if (MessageRx_PCM[n]==0x61 && MessageRx_PCM[n+1]==0x01) {dataVars() ; RequestPeriod = 70; prevRequest = curmillis; } // receive DataStream
}
// если контрольная сумма не совпала:
#ifdef debugPCM
else Serial.println("CRC fail!!!" );
#endif
message_size = 0; header=0; RESETheader_timer = 0; j=3; crc = 0;
}
// таймер ожидания байт (для успевания появления данных в буфере UART)
if (!Delay && curmillis - timerdelay > waitbyte_RX) Delay = 1;
// таймер сброса целостности сообщения (если данные оборвались посередине сообщения)
if (RESETheader_timer && curmillis - prevRESETheader > 200) {
#ifdef debugPCM
Serial.println(F("Message fail timeout"));
#endif
RESETheader_timer = 0; header = 0;}
// если нет ответа после запроса: +1 к счетчику неответов. Если накопилось 6 и более: делаем реинит.
if (request!=INIT && NOanswer_timer && curmillis - prev_NOanswer > RequestPeriod - RequestPeriod/10)
{
NOanswer_timer = 0; noanswers++;
if (noanswers>=6) { noanswers = 0; request = INIT; RequestPeriod = 3500;}
}
}// end receivePCM
void Troublecodes ()
{
if (MessageRx_PCM[n]==0x58 && MessageRx_PCM[n+1]==0x00){
myGLCD.clrScr();
drawscreen_three();
myGLCD.print("NO DTC", 180, 145);
}
// при получении сообщения о наличии ошибок DTC разберем сообщение выведем на экран ошибки
if (MessageRx_PCM[n]==0x58 && MessageRx_PCM[n+1]>0){
myGLCD.clrScr();
drawscreen_three();
for (int i=0; i<MessageRx_PCM[n+8-7]; i++ ) {
int y = i*35;
bool nolA=0; bool nolB =0;
if (!bitRead(MessageRx_PCM[n+11-7+(i*3)],6) && bitRead(MessageRx_PCM[n+11-7+(i*3)],7)){ myGLCD.setTextColor(GREEN, BLACK);
myGLCD.print(" -Passive-", 300, (75+y));} // если DTC пасивныый делаем цвет зеленый
if (bitRead(MessageRx_PCM[n+11-7+(i*3)],7) && bitRead(MessageRx_PCM[n+11-7+(i*3)],6)) { myGLCD.setTextColor(RED, BLACK);
myGLCD.print(" -Active-", 300, (75+y));} // если DTC активный, делаем цвет красный
myGLCD.print("ERROR ", 50, (75+y));
myGLCD.printNumI((i+1), 150, (75+y));
if (!bitRead(MessageRx_PCM[n+9-7+(i*3)],6) && !bitRead(MessageRx_PCM[n+9-7+(i*3)],7)) myGLCD.print(": P", 170, (75+y));
if (bitRead(MessageRx_PCM[n+9-7+(i*3)],6) && !bitRead(MessageRx_PCM[n+9-7+(i*3)],7)) myGLCD.print(": C", 170, (75+y));
if (!bitRead(MessageRx_PCM[n+9-7+(i*3)],6) && bitRead(MessageRx_PCM[n+9-7+(i*3)],7)) myGLCD.print(": B", 170, (75+y));
if (bitRead(MessageRx_PCM[n+9-7+(i*3)],6) && bitRead(MessageRx_PCM[n+9-7+(i*3)],7)) myGLCD.print(": U", 170, (75+y));
if (MessageRx_PCM[n+9-7+(i*3)]==0x00) {myGLCD.print("00", 230, (75+y)); nolA = 1;}
if (MessageRx_PCM[n+9-7+(i*3)]<=0x0F&&MessageRx_PCM[n+9-7+(i*3)]!=0) {myGLCD.print("0", 230, (75+y)); nolA = 1;}
if (nolA)myGLCD.print(String (MessageRx_PCM[n+9-7+(i*3)],HEX), 246, (75+y));
else myGLCD.print(String (MessageRx_PCM[n+9-7+(i*3)],HEX), 230, (75+y));
if (MessageRx_PCM[n+10-7+(i*3)]==0x00) {myGLCD.print("00", 262, (75+y)); nolB = 1;}
if (MessageRx_PCM[n+10-7+(i*3)]<=0x0F&&MessageRx_PCM[n+10-7+(i*3)]!=0) {myGLCD.print("0", 262, (75+y)); nolB = 1;}
if (nolB)myGLCD.print(String (MessageRx_PCM[n+10-7+(i*3)]),HEX, 278, (75+y));
else myGLCD.print(String (MessageRx_PCM[n+10-7+(i*3)],HEX), 262, (75+y));}}
request = PRESENT; RequestPeriod = 4000; prevRequest = curmillis;
}
void dataVars()
{
//Barom = MessageRx_PCM[39];
L100 = (float)LHor*100.0/(float)Speed;
LHor = (float)RPM* (float)InjQua*2.00/1000.0*60.00/1000.0/0.85;
MAF = ((MessageRx_PCM[n+22]*256)+MessageRx_PCM[n+23])/10;
BoostPres = ((MessageRx_PCM[n+24]*256)+MessageRx_PCM[n+25])/1000.0;
RPM = (MessageRx_PCM[n+35-7]*256)+MessageRx_PCM[n+36-7];
EGRmg = ((MessageRx_PCM[n+37-7]*256)+MessageRx_PCM[n+38-7])/10.0;
BoostPresCom = ((MessageRx_PCM[n+41-7]*256)+MessageRx_PCM[n+42-7])/1000.0;
Speed = ((MessageRx_PCM[n+47-7]*256)+MessageRx_PCM[n+48-7])/100;
DesaInjQua = ((MessageRx_PCM[n+53-7]*256)+MessageRx_PCM[n+54-7])/100.0;
InjQua = ((MessageRx_PCM[n+55-7]*256)+MessageRx_PCM[n+56-7])/100.0;
StaDaliv = ((MessageRx_PCM[n+57-7]*256)+MessageRx_PCM[n+58-7])/100.0;
PumpRPM = (MessageRx_PCM[n+59-7]*256)+MessageRx_PCM[n+60-7];
EGRPul = ((MessageRx_PCM[n+65-7]*256)+MessageRx_PCM[n+66-7])/100.0;
SolenPul = ((MessageRx_PCM[n+67-7]*256)+MessageRx_PCM[n+68-7])/100.0;
SolenPre = ((MessageRx_PCM[n+73-7]*256)+MessageRx_PCM[n+74-7])/100.0;
DesInj = ((MessageRx_PCM[n+75-7]*3)+(MessageRx_PCM[n+76-7])/100.0)+0.3;
ActInj = ((MessageRx_PCM[n+19-7]*3)+(MessageRx_PCM[n+20-7])/100.0)+0.3;
//TempAir = ((MessageRx_PCM[n+77-7]*26)-278)+MessageRx_PCM[n+78-7]/10.0;
//Temp = ((MessageRx_PCM[n+17-7]*26)-278)+MessageRx_PCM[n+18-7]/10.0;
//TempOil = ((MessageRx_PCM[n+21-7]*26)-278)+MessageRx_PCM[n+22-7]/10.0;
//TempFuel = ((MessageRx_PCM[n+61-7]*26)-278)+MessageRx_PCM[n+62-7]/10.0;
//ниже идут расчетные формулы более точные чем те что закоментированы выше
int A = 0;
if (MessageRx_PCM[n+77-7]<=0x0A) A = 277;
if (MessageRx_PCM[n+77-7]==0x0B || MessageRx_PCM[n+77-7]==0x0C) A = 278;
if (MessageRx_PCM[n+77-7]>=0x0D) A = 279;
double B = MessageRx_PCM[n+78-7]/10.0;
double cel , drob ;
drob = modf(B, &cel);
if (drob>0.6) cel++;
TempAir = ((MessageRx_PCM[n+77-7]*26)-A)+cel;
if (MessageRx_PCM[n+17-7]<=0x0A) A = 277;
if (MessageRx_PCM[n+17-7]==0x0B || MessageRx_PCM[n+17-7]==0x0C) A = 278;
if (MessageRx_PCM[n+17-7]>=0x0D) A = 279;
B = MessageRx_PCM[n+18-7]/10.0;
drob = modf(B, &cel);
if (drob>0.6) cel++;
Temp = ((MessageRx_PCM[n+17-7]*26)-A)+cel;
if (MessageRx_PCM[n+21-7]<=0x0A) A = 277;
if (MessageRx_PCM[n+21-7]==0x0B || MessageRx_PCM[n+21-7]==0x0C) A = 278;
if (MessageRx_PCM[n+21-7]>=0x0D) A = 279;
B = MessageRx_PCM[n+22-7]/10.0;
drob = modf(B, &cel);
if (drob>0.6) cel++;
TempOil = ((MessageRx_PCM[n+21-7]*26)-A)+cel;
if (MessageRx_PCM[n+61-7]<=0x0A) A = 277;
if (MessageRx_PCM[n+61-7]==0x0B || MessageRx_PCM[n+61-7]==0x0C) A = 278;
if (MessageRx_PCM[n+61-7]>=0x0D) A = 279;
B = MessageRx_PCM[n+62-7]/10.0;
drob = modf(B, &cel);
if (drob>0.6) cel++;
TempFuel = ((MessageRx_PCM[n+61-7]*26)-A)+cel;
//----------------------------------------------------------
//страниц HOME
//----------------------------------------------------------
//myGLCD.setBackColor(RED);
myGLCD.setTextColor(WHITE, BLACK);
//myGLCD.setBackColor(RED);
if ((Speed != Speed_last) || reNew) {myGLCD.printNumI(Speed, 360, 7, 3); Speed_last=Speed;}
if (currentPage == '0') {
if ((LHor != LHor_last) || reNew) {myGLCD.printNumF(LHor, 1, 75, 40, '.',4); LHor_last=LHor;}
if ((L100 != L100_last) || reNew) {myGLCD.printNumF(L100, 1, 225, 40,'.',4 ); L100_last=L100;}
if ((L100M != L100M_last) || reNew) {myGLCD.printNumF(L100M, 1, 75, 75,'.',4 ); L100M_last=L100M;}
if ((L100SR_TFT != L100SR_TFT_last) || reNew) {myGLCD.printNumF(L100SR_TFT, 1, 225, 75,'.',4 ); L100SR_TFT_last=L100SR_TFT;}
if ((kmREFUELING != kmREFUELING_last) || reNew) {myGLCD.printNumI(kmREFUELING, 90, 110,3 ); kmREFUELING_last=kmREFUELING;}
//if (Fuel<53)
if ((Fuel != Fuel_last) || reNew) {myGLCD.printNumF(Fuel, 1, 225, 110,'.',4); Fuel_last=Fuel;}
//else myGLCD.print("MAX", 210, 110);
if ((kmTrip != kmTrip_last) || reNew) {myGLCD.printNumF(kmTrip, 1, 60, 145,'.',5); kmTrip_last=kmTrip;}
if ((FuelTrip != FuelTrip_last) || reNew) {myGLCD.printNumF(FuelTrip, 1, 210, 145,'.',5); FuelTrip_last=FuelTrip;}
if ((PumpRPM != PumpRPM_last) || reNew) {myGLCD.printNumI(PumpRPM, 230, 180,4); PumpRPM_last=PumpRPM;}
if ((RPM != RPM_last) || reNew) {myGLCD.printNumI(RPM, 230, 215,4); RPM_last=RPM;}
if ((Fuel2 != Fuel2_last) || reNew) {myGLCD.printNumF(Fuel2, 1, 10, 215,'.',4); Fuel2_last=Fuel2;}
if ((Temp != Temp_last) || reNew) {myGLCD.printNumI(Temp, 415, 40, 3); Temp_last=Temp;}
if ((TempOil != TempOil_last) || reNew) {myGLCD.printNumI(TempOil, 415, 75, 3); TempOil_last=TempOil;}
if ((TempFuel != TempFuel_last) || reNew) {myGLCD.printNumI(TempFuel, 415, 110,3); TempFuel_last=TempFuel;}
//myGLCD.printNumI(sensors.getTempCByIndex(0), 415, 145 , 3);
if ((t != t_last) || reNew) {myGLCD.printNumI(t, 415, 180, 3); t_last=t;}
if ((TempAir != TempAir_last) || reNew) {myGLCD.printNumI(TempAir, 415, 215, 3); TempAir_last=TempAir;}
reNew = 0;
}
//----------------------------------------------------------
//страниц INF1
//----------------------------------------------------------
if (currentPage == '1') {
if ((StaDaliv != StaDaliv_last) || reNew) {myGLCD.printNumF(StaDaliv,1, 385, 40,'.', 4); StaDaliv_last=StaDaliv;}
if ((DesInj != DesInj_last) || reNew) {myGLCD.printNumF(DesInj,1, 385, 75, '.', 4); DesInj_last=DesInj;}
if ((ActInj != ActInj_last) || reNew) {myGLCD.printNumF(ActInj,1, 385, 110,'.', 4); ActInj_last=ActInj;}
if ((DesaInjQua != DesaInjQua_last) || reNew) {myGLCD.printNumF(DesaInjQua,1, 385, 145,'.', 4);DesaInjQua_last=DesaInjQua;}
if ((InjQua != InjQua_last) || reNew) {myGLCD.printNumF(InjQua,1, 385, 180,'.', 4); InjQua_last=InjQua;}
if ((MAF != MAF_last) || reNew) {myGLCD.printNumI(MAF, 170, 215, 4); MAF_last=MAF;}
if ((h != h_last) || reNew) {myGLCD.printNumF(h, 1, 430, 215, 3); h_last=h;}
reNew = 0;
}
//----------------------------------------------------------
//страниц INF2
//----------------------------------------------------------
if (currentPage == '2') {
if ((BoostPres != BoostPres_last) || reNew) {myGLCD.printNumF(BoostPres,1, 400, 40,'.', 4); BoostPres_last=BoostPres;}
if ((BoostPresCom != BoostPresCom_last) || reNew) {myGLCD.printNumF(BoostPresCom,1, 400, 75,'.', 4); BoostPresCom_last=BoostPresCom;}
if ((EGRmg != EGRmg_last) || reNew) {myGLCD.printNumI(EGRmg, 400, 110, 4); EGRmg_last=EGRmg;}
if ((EGRPul != EGRPul_last) || reNew) {myGLCD.printNumF(EGRPul,1, 400, 145,'.', 4); EGRPul_last=EGRPul;}
if ((SolenPul != SolenPul_last) || reNew) {myGLCD.printNumF(SolenPul, 1, 400, 180,'.', 4); SolenPul_last=SolenPul;}
if ((SolenPre != SolenPre_last) || reNew) {myGLCD.printNumF(SolenPre, 0, 400, 215,'.', 4); SolenPre_last=SolenPre;}
reNew = 0;
}
//reNew = 0;
}
void sendMessagePCM(const byte &command)
{
#ifdef debugPCM
Serial.print (F("Send request ")); Serial.print (textRequest[command]); Serial.print (F(" to PCM ")); Serial.println (millis());
#endif
if (command != INIT) {NOanswer_timer = 1; prev_NOanswer = curmillis;} //т.к. сейчас будем делать запрос, то запускаем таймер контроля неответов
byte size = PCM_Message_TX[command][0];
const byte siZe = size+4;
byte Mes[siZe];
byte Checksum = 0;
for(byte i=0; i<siZe; i++) {
if (i==0) {Mes[i]=size; bitWrite(Mes[i], 7 , 1);}
if (i==1) Mes[i] = PCM_address;
if (i==2) Mes[i] = DIAG_address;
if (i==3) {for (byte t=1; t<size+1; t++ ) {
Mes[i]=PCM_Message_TX [command][t];
Checksum+=Mes[i] ;
K_LINE_PCM.write (Mes[i]);
if (command == INIT) delay (5); else delay (delaybyte_TX);
K_LINE_PCM.read();
i++;}}
if (i!=siZe-1) Checksum+=Mes[i];
else Mes[i] = Checksum;
K_LINE_PCM.write (Mes[i]);
if (command == INIT) delay (5); else delay (delaybyte_TX);
K_LINE_PCM.read();
}
}// end sendMessagePCM
#if defined debugPCM or debugGAUGE
void printDebugRX (const byte &inbyte) {if (inbyte<=15) Serial.print(F("0")); Serial.print (inbyte, HEX); Serial.print (F(" "));}
#endif
#ifdef debugPCM
void printDebugRX_CSgood(){
if (MessageRx_PCM[n]==0xC1 && MessageRx_PCM[n+1]==0x6B && MessageRx_PCM[n+2]==0x8F) {Serial.println (F(" Initialization OK!!!!")); }
else if (MessageRx_PCM[n]==0x58 && MessageRx_PCM[n+1]==0x00) {Serial.println (F(" NO DTC "));}
else if (MessageRx_PCM[n]==0x58 && MessageRx_PCM[n+1] >0x00) {Serial.println (F(" DTC is found!"));}
else if (MessageRx_PCM[n]==0x54 && MessageRx_PCM[n+1]==0xFF && MessageRx_PCM[n+2]==0x00){Serial.println (F(" DTC CLEARED "));}
else if (MessageRx_PCM[n]==0x61 && MessageRx_PCM[n+1]==0x01) {Serial.println (F(" Receive PCM DATAstream"));}}
#endif
void Menu () {
TouchHOME();
if (currentPage == '0') {
TouchINF1();
TouchINF2();
TouchCHECK(); }
if (currentPage == '1') {
TouchINF2();
TouchCHECK(); }
if (currentPage == '2') {
TouchINF1();
TouchCHECK(); }
if (currentPage == '3') {
TouchREAD();
TouchERASE(); }}
void drawHomeScreen() {
reNew = 1;
line() ;
Watch ();
//myGLCD.print(":", 290, 5);
myGLCD.print("/", 115, 7);
myGLCD.print("/", 160, 7);
myGLCD.setTextColor(RED, BLACK); // цвет линии и текста красный
myGLCD.drawLine(295,35,295,248); // линия вертикальная
myGLCD.drawLine(145,35,145,178); // линия вертикальная
myGLCD.drawLine(80,178,80,247); // линия вертикальная
myGLCD.print("L/H", 10, 40);
myGLCD.print("L/A", 148, 40);
myGLCD.print("L/V", 10, 75);
myGLCD.print("L/M", 148, 75);
myGLCD.print("D/K", 10, 110);
myGLCD.print("D/L", 148, 110);
myGLCD.print("V/K", 10, 145);
myGLCD.print("V/L", 148, 145);
myGLCD.print("PUMP RPM", 82, 180);
myGLCD.print("ENGI RPM", 82, 215);
myGLCD.print("D/L/A", 10, 180);
myGLCD.print("Motor C", 300, 40);
myGLCD.print("OIL C", 300, 75);
myGLCD.print("FUEL C", 300, 110);
myGLCD.print("INTER C", 300, 145);
myGLCD.print("EXTER C", 300, 180);
myGLCD.print("INTAIR C", 300, 215);
//myGLCD.setTextColor(RED);
myGLCD.drawRoundRect (15, 255, 145, 310);
myGLCD.print("INF 1", 55, 270);
myGLCD.drawRoundRect (175, 255, 305, 310);
myGLCD.print("INF 2", 215, 270);
myGLCD.drawRoundRect (335, 255, 465, 310);
myGLCD.print("CHECK", 365, 270);
myGLCD.drawRoundRect (1, 1, 77, 37);
myGLCD.print("HOME", 10, 7);
myGLCD.print("Km/h", 410, 7);
}
//-------------------------------------------------
void drawscreen_one() {
reNew = 1;
line() ;
Watch ();
//myGLCD.print(":", 290, 5);
myGLCD.print("/", 115, 7);
myGLCD.print("/", 160, 7);
myGLCD.setTextColor(RED, BLACK); // цвет линии и текста красный
myGLCD.print("Start of Delivery *CA:", 10, 40);
myGLCD.print("Desir inject Start *CA:", 10, 75);
myGLCD.print("Actua Inject Start *CA:", 10, 110);
myGLCD.print("Desir Inject Quan mg/s:", 10, 145);
myGLCD.print("Actu Inject Quant mg/s:", 10, 180);
myGLCD.print("MAF mg/s:", 10, 215);
myGLCD.print("Humedad %:", 255, 215);
//myGLCD.setTextColor(RED);
myGLCD.drawRoundRect (175, 255, 305, 310);
myGLCD.print("INF 2", 215, 270);
myGLCD.drawRoundRect (335, 255, 465, 310);
myGLCD.print("CHECK", 365, 270);
myGLCD.drawRoundRect (1, 1, 77, 37);
myGLCD.print("HOME", 10, 7);
myGLCD.print("Km/h", 410, 7);
}
//-------------------------------------------------
void drawscreen_two() {
reNew = 1;
line() ;
Watch ();
//myGLCD.print(":", 290, 5);
myGLCD.print("/", 115, 7);
myGLCD.print("/", 160, 7);
myGLCD.setTextColor(RED, BLACK); // цвет линии и текста красный
myGLCD.print("Boost Press Bar:", 10, 40);
myGLCD.print("Boost Press Com Bar:", 10, 75);
myGLCD.print("EGR command mg/s:", 10, 110);
myGLCD.print("EGR Pulse Ratio %:", 10, 145);
myGLCD.print("Solenoide Pulse %:", 10, 180);
myGLCD.print("Solenoide Boost %:", 10, 215);
//myGLCD.setColor(RED);
myGLCD.drawRoundRect (15, 255, 145, 310);
myGLCD.print("INF 1", 55, 270);
myGLCD.drawRoundRect (335, 255, 465, 310);
myGLCD.print("CHECK", 365, 270);
myGLCD.drawRoundRect (1, 1, 77, 37);
myGLCD.print("HOME", 10, 7);
myGLCD.print("Km/h", 410, 7);
}
//----------------------------------------------------------------------------
void drawscreen_three() {
reNew = 1;
Watch ();
//myGLCD.print(":", 290, 5);
myGLCD.print("/", 115, 7);
myGLCD.print("/", 160, 7);
myGLCD.setTextColor(RED, BLACK); // цвет линии красный
myGLCD.drawLine(1,35,479,35); // линия горизонтальная
myGLCD.drawLine(1,248,479,248); // линия горизонтальная
//myGLCD.setTextColor(RED);
myGLCD.drawRoundRect (15, 255, 145, 310);
myGLCD.print("ERASE", 55, 270);
myGLCD.drawRoundRect (335, 255, 465, 310);
myGLCD.print("READ", 365, 270);
myGLCD.drawRoundRect (1, 1, 77, 37);
myGLCD.print("HOME", 10, 5);
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//кнопки тач . координаты и переходы
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void TouchHOME(){
TSPoint p = ts.getPoint();
pinMode(XM, OUTPUT);
pinMode(YP, OUTPUT);
if (p.z > 10 && p.z < 1000)
{if (p.x > 140 && p.x < 320 && p.y > 140 && p.y < 260 && p.z > MINPRESSURE && p.z < MAXPRESSURE)
{ myGLCD.drawRoundRect (1, 1, 77, 37);
currentPage = '0';
request = PID; RequestPeriod = 10; prevRequest = curmillis; // на PCM в этом окне посылается запрос текущих параметров
myGLCD.clrScr();
drawHomeScreen();
x = 0;
y = 0;
p.z = 0;}}}
void TouchINF1(){
TSPoint p = ts.getPoint();
pinMode(XM, OUTPUT);
pinMode(YP, OUTPUT);
if (p.z > 10 && p.z < 1000)
{
if (p.x > 150 && p.x < 450 && p.y > 770 && p.y < 890 && p.z > MINPRESSURE && p.z < MAXPRESSURE)
{ myGLCD.drawRoundRect (15, 255, 145, 310);
currentPage = '1';
request = PID; RequestPeriod = 10; prevRequest = curmillis; // на PCM в этом окне посылается запрос текущих параметров
myGLCD.clrScr();
drawscreen_one();
x = 0;
y = 0;
p.z = 0;}}}
void TouchINF2(){
TSPoint p = ts.getPoint();
pinMode(XM, OUTPUT);
pinMode(YP, OUTPUT);
if (p.z > 10 && p.z < 1000)
{
if (p.x > 450 && p.x < 680 && p.y > 770 && p.y < 890 && p.z > MINPRESSURE && p.z < MAXPRESSURE)
{ myGLCD.drawRoundRect (175, 255, 305, 310);
currentPage = '2';
request = PID; RequestPeriod = 600; prevRequest = curmillis; // на PCM в этом окне посылается запрос текущих параметров
myGLCD.clrScr();
drawscreen_two();
x = 0;
y = 0;
p.z = 0;}}}
void TouchCHECK(){
TSPoint p = ts.getPoint();
pinMode(XM, OUTPUT);
pinMode(YP, OUTPUT);
if (p.z > 10 && p.z < 1000)
{
if (p.x > 690 && p.x < 950 && p.y > 770 && p.y < 890 && p.z > MINPRESSURE && p.z < MAXPRESSURE)
{ myGLCD.drawRoundRect (335, 255, 465, 310);
currentPage = '3';
// request = DTCREAD; RequestPeriod = 10; prevRequest = curmillis; // на PCM в этом окне посылается запрос чтения ошибок
myGLCD.clrScr();
drawscreen_three();
x = 0;
y = 0;
p.z = 0;}}}
void TouchREAD(){
TSPoint p = ts.getPoint();
pinMode(XM, OUTPUT);
pinMode(YP, OUTPUT);
if (p.z > 10 && p.z < 1000)
{
if (p.x > 690 && p.x < 950 && p.y > 770 && p.y < 890 && p.z > MINPRESSURE && p.z < MAXPRESSURE)
{ myGLCD.drawRoundRect (335, 255, 465, 310);
request = DTCREAD; RequestPeriod = 300; prevRequest = curmillis; // на PCM при нажатии этой кнопки посылается запрос чтения ошибок
x = 0;
y = 0;
p.z = 0;}}}
void TouchERASE(){
TSPoint p = ts.getPoint();
pinMode(XM, OUTPUT);
pinMode(YP, OUTPUT);
if (p.z > 10 && p.z < 1000)
{
if (p.x > 150 && p.x < 450 && p.y > 770 && p.y < 890 && p.z > MINPRESSURE && p.z < MAXPRESSURE)
{myGLCD.drawRoundRect (15, 255, 145, 310);
request = DTCERASE; RequestPeriod = 300; prevRequest = curmillis; // на PCM при нажатии этой кнопки посылается запрос удаления ошибок
myGLCD.clrScr();
drawscreen_three();
myGLCD.print("DTC BORRADO", 180, 145);
x = 0;
y = 0;
p.z = 0;}}}
////////////////////////////////////////////////////////////////////////////////////////
//прорисовка линий
///////////////////////////////////////////////////////////////////////////////////////
void line() {
//myGLCD.setTextColor(RED); // цвет линии красный
myGLCD.drawLine(1,35,479,35); // линия горизонтальная
myGLCD.drawLine(1,73,479,73); // линия горизонтальная
myGLCD.drawLine(1,108,479,108); // линия горизонтальная
myGLCD.drawLine(1,143,479,143); // линия горизонтальная
myGLCD.drawLine(1,178,479,178); // линия горизонтальная
myGLCD.drawLine(1,212,479,212); // линия горизонтальная
myGLCD.drawLine(1,248,479,248); // линия горизонтальная
}
void Watch (){
DateTime now = rtc.now();
int minut = now.minute();
int hour = now.hour();
int mon = now.month();
int date = now.day();
int Year = now.year();
static int minut_last;
static int hour_last;
static int mon_last;
static int date_last;
static int Year_last;
myGLCD.setTextColor(WHITE, BLACK); //белый цвет цифры
if (date != date_last || reNew){ myGLCD.printNumI(date, 85, 7, 2, '0'); date_last = date; }
if (mon!=mon_last || reNew){myGLCD.printNumI(mon, 130, 7, 2, '0'); mon_last = mon; }
if (Year!=Year_last || reNew) { myGLCD.printNumI(Year, 175, 7); Year_last = Year; }
if (hour!=hour_last || reNew){ myGLCD.printNumI(hour, 255, 7, 2, '0'); hour_last = hour; }
if (minut!=minut_last || reNew ){ myGLCD.printNumI(minut, 300, 7, 2, '0'); minut_last = minut; }
}
дык а старый скетч раз в секунду тоже обновлялся. а этот даже чуточку быстрее. Макс сделай все что сможешь, а там уже как будет так будет. И СПАСИБО зараннее
Привет, MaksVV! Наконец-то дошли руки сделать твое задание из поста №1399:
"подключаешь эксплоер к машине. Параллельно цепляешь сниффер, (та же к-лайн ардуина только со скетчем сниффера), он много раз тут обсуждался ищи. Когда будет сниф, можно будет о чём то говорить. Расшаривается быстрее, без всяких документов. Очень часто описание протокола не соответствует дейтсвительности. "
В программе Шевроле-Эксплорер установил только параметр Напряжение бортсети, получилось вот так:
Лог сделан твоим сниффером из поста 1197. Напомню что автомобиль Нексия N-150, 16-ти клапанный, ЭБУ-Сириус-42. При запросах Пидов ЭБУ не выдавал MAF, напряжение бортсети, время впрыска и др.
Подскажи, пож-та, как перелопатить всю эту массу байтов и найти там хоть что-то полезное!?
Настроил работу K-line. соединяется через Ардуино Уно. Загрузил ваш скетч из #41 http://arduino.ru/forum/proekty/bortovoi-kompyuter-dlya-opel-zafira#comment-290979, который идет в самом начале темы. Выдает, что подключение проходит, а температуру не видит корректно. Попробовал подключить OP COM к машине и посмотреть что идет через Device Monitor. Я подозреваю, что в моей машине адрес обращения к температуре другой или я не прав? в чем моя ошибка? Почему не приходят данные о температуре? На картинке я пытался подключиться по OP COM к мотору и снять даннные в разделе Measurement на второй странице, закрыв все запросы кроме запроса на температуру мотора. Послее подмены вашего запроса в скетче на свой 82 11 F1 21 01 A6 показания какие то приходят, но я не те, что выдает OP COM
Мне не совсем ясно как мне выудить из того что я имею запрос на температуру? помогите, пожалуйста, объясните.
Abt, подключиться к автомобилю опкомом. Параллельно на к линию подключить сниффер на связке ардуино/клайн. Скетч сниффера есть #1147. Внимательно с номерами пинов софт сериала и клайн на ардуино. Результат сюда
можно конечно. хоть как то решить это. так это нужно в моем шрифте перерисовывать получается. я так понимю вот это { 21, 14, 24, 16, 1, -23 }, // 0x23 '#'
этот
const uint8_t Chosence_Bold16pt7bBitmaps[] PROGMEM = { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xE7, 0xE7, 0xE7, 0xE7, 0xE7, 0xE7, 0xE7, 0xE7, 0xE7, 0x07, 0x3C, 0x3C, 0xE0, 0xF3, 0x83, 0x8E, 0x0E, 0x38, 0x39, 0xE1, 0xE7, 0x87, 0x9C, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xC7, 0x3C, 0x3C, 0xE3, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x39, 0xE1, 0xE7, 0x87, 0x9C, 0x1C, 0x70, 0x71, 0xC1, 0xCF, 0x07, 0x3C, 0x3C, 0xE0, 0x1F, 0x03, 0xE0, 0x7C, 0x3F, 0xEF, 0xFF, 0xFF, 0xF8, 0x3F, 0x07, 0xE0, 0xFC, 0x1F, 0x83, 0xF0, 0x0F, 0x00, 0xF8, 0x1F, 0xC1, 0xFE, 0x0F, 0xC0, 0x7C, 0x03, 0xF0, 0x7E, 0x0F, 0xC1, 0xF8, 0x3F, 0x07, 0xFF, 0xFF, 0xFD, 0xFF, 0x0F, 0x81, 0xF0, 0x3E, 0x00, 0x7F, 0x07, 0x1F, 0xF1, 0xC3, 0xFE, 0x38, 0x71, 0xCF, 0x0E, 0x39, 0xC1, 0xC7, 0x38, 0x38, 0xEE, 0x07, 0x1D, 0xC0, 0xFF, 0xF8, 0x1F, 0xFE, 0x01, 0xFF, 0xC0, 0x00, 0x70, 0x00, 0x0E, 0x00, 0x03, 0xFF, 0x80, 0x7F, 0xF8, 0x1F, 0xFF, 0x03, 0xB8, 0xE0, 0x77, 0x1C, 0x1C, 0xE3, 0x83, 0x9C, 0x70, 0xF3, 0x8E, 0x1C, 0x7F, 0xC3, 0x8F, 0xF8, 0xE0, 0xFE, 0x3F, 0x00, 0x1F, 0xE0, 0x07, 0xF8, 0x01, 0xCE, 0x00, 0x73, 0x80, 0x1C, 0xE0, 0x07, 0x38, 0x01, 0xCE, 0x00, 0x7F, 0x80, 0x0F, 0xC0, 0x03, 0xF1, 0xE0, 0x78, 0x78, 0x3E, 0x1C, 0x1F, 0xC7, 0x07, 0xFB, 0xC3, 0xDF, 0xF0, 0xE3, 0xF8, 0x38, 0x7E, 0x0E, 0x0F, 0xC3, 0x83, 0xFC, 0xF1, 0xFF, 0x9F, 0xF9, 0xE7, 0xFC, 0x10, 0x7C, 0x00, 0xFF, 0xFF, 0xFF, 0xE0, 0x1D, 0xF7, 0xFC, 0xE3, 0x8E, 0x38, 0xE3, 0x8E, 0x38, 0xE3, 0x8E, 0x38, 0xE3, 0x8E, 0x38, 0xE3, 0x8E, 0x38, 0xE3, 0x8F, 0x1F, 0x7C, 0x70, 0xC7, 0xBC, 0xF3, 0x9C, 0xE7, 0x39, 0xCE, 0x73, 0x9C, 0xE7, 0x39, 0xCE, 0x73, 0x9C, 0xE7, 0x39, 0xDF, 0xEF, 0x60, 0x0E, 0x01, 0xC2, 0x38, 0x76, 0x6F, 0xFF, 0xFF, 0xC7, 0x81, 0xF8, 0x7B, 0x8E, 0x30, 0x44, 0x00, 0x07, 0x00, 0x38, 0x01, 0xC0, 0x0E, 0x00, 0x70, 0x7F, 0xFF, 0xFF, 0xFF, 0xFF, 0x07, 0x00, 0x38, 0x01, 0xC0, 0x0E, 0x00, 0x70, 0x00, 0xFF, 0xFF, 0x76, 0x66, 0xC0, 0xFF, 0xFF, 0xFF, 0xFC, 0xFF, 0xFF, 0x0E, 0x1C, 0x78, 0xF1, 0xC3, 0x87, 0x0E, 0x3C, 0x70, 0xE1, 0xC3, 0x8F, 0x1E, 0x38, 0x70, 0xE1, 0xC7, 0x8E, 0x1C, 0x38, 0x70, 0x7F, 0xBF, 0xFF, 0xFF, 0x87, 0xE1, 0xF8, 0x7E, 0x1F, 0x87, 0xE1, 0xF8, 0x7E, 0x1F, 0x87, 0xE1, 0xF8, 0x7E, 0x1F, 0x87, 0xE1, 0xF8, 0x7E, 0x1F, 0x87, 0xE1, 0xFF, 0xFF, 0xFD, 0xFE, 0x1E, 0x1F, 0xC3, 0xF8, 0x7F, 0x00, 0xE0, 0x1C, 0x03, 0x80, 0x70, 0x0E, 0x01, 0xC0, 0x38, 0x07, 0x00, 0xE0, 0x1C, 0x03, 0x80, 0x70, 0x0E, 0x01, 0xC0, 0x38, 0x07, 0x00, 0xE1, 0xFF, 0xFF, 0xFF, 0xFF, 0x7F, 0xBF, 0xEF, 0xFF, 0x87, 0xE1, 0xF8, 0x7E, 0x1F, 0x87, 0x01, 0xC0, 0x70, 0x3C, 0x3F, 0x1F, 0x9F, 0xC7, 0xE3, 0xE0, 0xF0, 0x38, 0x0E, 0x03, 0x80, 0xE0, 0x3F, 0xFF, 0xFF, 0xFF, 0x7F, 0xBF, 0xFF, 0xFF, 0x87, 0xE1, 0xF8, 0x7E, 0x1F, 0x87, 0x01, 0xC0, 0xF0, 0xF8, 0x3C, 0x0F, 0x80, 0xF0, 0x1F, 0x87, 0xE1, 0xF8, 0x7E, 0x1F, 0x87, 0xE1, 0xFF, 0xFF, 0xFD, 0xFE, 0x0E, 0x01, 0xE0, 0x1E, 0x01, 0xE0, 0x1C, 0x03, 0xC0, 0x3C, 0x03, 0xDC, 0x39, 0xC3, 0x9C, 0x79, 0xC7, 0x9C, 0x71, 0xC7, 0x1C, 0xF1, 0xCF, 0xFF, 0xFF, 0xFF, 0xFF, 0x01, 0xC0, 0x1C, 0x01, 0xC0, 0x1C, 0x01, 0xC0, 0x1C, 0xFF, 0xFF, 0xFF, 0xFF, 0x80, 0xE0, 0x38, 0x0E, 0x03, 0x80, 0xE0, 0x38, 0x0F, 0xFB, 0xFF, 0xFF, 0xC0, 0x70, 0x1C, 0x07, 0x01, 0xC0, 0x70, 0x1C, 0x07, 0x03, 0xFF, 0xEF, 0xFB, 0xF8, 0x1F, 0xDF, 0xF7, 0xFF, 0xC0, 0xE0, 0x38, 0x0E, 0x03, 0x80, 0xE0, 0x38, 0x0F, 0xFB, 0xFF, 0xFF, 0xF8, 0x7E, 0x1F, 0x87, 0xE1, 0xF8, 0x7E, 0x1F, 0x87, 0xE1, 0xFF, 0xFF, 0xFD, 0xFE, 0xFF, 0xFF, 0xFF, 0xFF, 0x80, 0xF0, 0x1C, 0x03, 0x80, 0xF0, 0x1E, 0x03, 0xC0, 0x70, 0x0E, 0x03, 0xC0, 0x78, 0x0E, 0x01, 0xC0, 0x78, 0x0F, 0x01, 0xE0, 0x38, 0x07, 0x01, 0xE0, 0x3C, 0x07, 0x00, 0xE0, 0x7F, 0xBF, 0xFF, 0xFF, 0x87, 0xE1, 0xF8, 0x7E, 0x1F, 0x87, 0xE1, 0xFC, 0xF7, 0xF9, 0xFE, 0x7F, 0x9F, 0xEF, 0x3F, 0x87, 0xE1, 0xF8, 0x7E, 0x1F, 0x87, 0xE1, 0xFF, 0xFF, 0xFD, 0xFE, 0x7F, 0xBF, 0xFF, 0xFF, 0x87, 0xE1, 0xF8, 0x7E, 0x1F, 0x87, 0xE1, 0xF8, 0x7E, 0x1F, 0xFF, 0xFF, 0xDF, 0xF0, 0x1C, 0x07, 0x01, 0xC0, 0x70, 0x1C, 0x07, 0x03, 0xFF, 0xEF, 0xFB, 0xF8, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0F, 0xFF, 0xF7, 0x66, 0x6E, 0x00, 0x08, 0x01, 0xC0, 0x7E, 0x0F, 0xF1, 0xFE, 0x7F, 0x83, 0xF0, 0x1F, 0x80, 0xFF, 0x00, 0xFF, 0x01, 0xFE, 0x03, 0xF0, 0x03, 0x80, 0x04, 0xFF, 0xFF, 0xFF, 0xFF, 0xFE, 0x00, 0x00, 0x00, 0x7F, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x07, 0x00, 0x3E, 0x01, 0xFC, 0x03, 0xFC, 0x07, 0xF8, 0x07, 0xE0, 0x3F, 0x0F, 0xF1, 0xFE, 0x3F, 0xC1, 0xF0, 0x0E, 0x00, 0x00, 0x00, 0x7F, 0xBF, 0xFF, 0xFF, 0x87, 0xE1, 0xF8, 0x7E, 0x1F, 0x87, 0x01, 0xC0, 0xF0, 0x78, 0x3E, 0x0F, 0x03, 0x80, 0xE0, 0x38, 0x0E, 0x03, 0x80, 0x00, 0x00, 0x1E, 0x07, 0x81, 0xE0, 0x78, 0x07, 0xFC, 0x01, 0xFF, 0xF0, 0x3F, 0xFF, 0x87, 0xC0, 0x7C, 0x78, 0x03, 0xCF, 0x3E, 0xDE, 0xE7, 0xFC, 0xEE, 0x7F, 0xCE, 0xE7, 0x1C, 0xEE, 0x71, 0xCE, 0xE7, 0x1C, 0xEE, 0x71, 0xCE, 0xE7, 0x1C, 0xEE, 0x71, 0xCE, 0xE7, 0x1C, 0xEE, 0x71, 0xCE, 0xE7, 0xFF, 0xEE, 0x7F, 0xFC, 0xF3, 0xF7, 0x87, 0x80, 0x00, 0x7C, 0x00, 0x03, 0xFF, 0xFF, 0x1F, 0xFF, 0xF0, 0x7F, 0xFF, 0x1F, 0x03, 0xE0, 0x7C, 0x0D, 0xC3, 0xB8, 0x77, 0x0E, 0xE1, 0xDC, 0x3B, 0x87, 0x70, 0xEF, 0x3D, 0xE7, 0x9C, 0xE3, 0x9C, 0x73, 0xFE, 0x7F, 0xCF, 0xFF, 0xC7, 0xF8, 0xFE, 0x0F, 0xC1, 0xF8, 0x3F, 0x07, 0xFF, 0xBF, 0xFF, 0xFF, 0x87, 0xE1, 0xF8, 0x7E, 0x1F, 0x87, 0xE1, 0xF8, 0xFF, 0xFB, 0xFC, 0xFF, 0xB8, 0xFE, 0x1F, 0x87, 0xE1, 0xF8, 0x7E, 0x1F, 0x87, 0xE3, 0xFF, 0xEF, 0xFB, 0xF8, 0x7F, 0xBF, 0xFF, 0xFF, 0x87, 0xE1, 0xF8, 0x7E, 0x1F, 0x87, 0xE0, 0x38, 0x0E, 0x03, 0x80, 0xE0, 0x38, 0x0E, 0x03, 0x80, 0xE1, 0xF8, 0x7E, 0x1F, 0x87, 0xE1, 0xFF, 0xFF, 0xFD, 0xFE, 0xFF, 0xBF, 0xEF, 0xFF, 0x87, 0xE1, 0xF8, 0x7E, 0x1F, 0x87, 0xE1, 0xF8, 0x7E, 0x1F, 0x87, 0xE1, 0xF8, 0x7E, 0x1F, 0x87, 0xE1, 0xF8, 0x7E, 0x1F, 0x87, 0xE3, 0xFF, 0xEF, 0xFB, 0xF8, 0xFF, 0xFF, 0xFF, 0xFF, 0x80, 0xE0, 0x38, 0x0E, 0x03, 0x80, 0xE0, 0x38, 0x0F, 0xFF, 0xFF, 0xFF, 0xF8, 0x0E, 0x03, 0x80, 0xE0, 0x38, 0x0E, 0x03, 0x80, 0xE0, 0x3F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x80, 0xE0, 0x38, 0x0E, 0x03, 0x80, 0xE0, 0x38, 0x0F, 0xFF, 0xFF, 0xFF, 0xF8, 0x0E, 0x03, 0x80, 0xE0, 0x38, 0x0E, 0x03, 0x80, 0xE0, 0x38, 0x0E, 0x03, 0x80, 0x7F, 0xBF, 0xFF, 0xFF, 0x87, 0xE1, 0xF8, 0x7E, 0x1F, 0x87, 0xE0, 0x38, 0x0E, 0x7F, 0x9F, 0xE7, 0xF8, 0x7E, 0x1F, 0x87, 0xE1, 0xF8, 0x7E, 0x1F, 0x87, 0xF1, 0xDF, 0xF7, 0xFC, 0x7F, 0xE1, 0xF8, 0x7E, 0x1F, 0x87, 0xE1, 0xF8, 0x7E, 0x1F, 0x87, 0xE1, 0xF8, 0x7F, 0xFF, 0xFF, 0xFF, 0xF8, 0x7E, 0x1F, 0x87, 0xE1, 0xF8, 0x7E, 0x1F, 0x87, 0xE1, 0xF8, 0x7E, 0x1F, 0x87, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x1F, 0xC7, 0xF1, 0xFC, 0x07, 0x01, 0xC0, 0x70, 0x1C, 0x07, 0x01, 0xC0, 0x70, 0x1C, 0x07, 0x01, 0xC0, 0x70, 0x1C, 0x07, 0xE1, 0xF8, 0x7E, 0x1F, 0x87, 0xE1, 0xFF, 0xFF, 0xFD, 0xFE, 0xE1, 0xF8, 0x7E, 0x1F, 0x87, 0xE1, 0xF8, 0x7E, 0x1F, 0x87, 0xE1, 0xF8, 0xFF, 0xFB, 0xFC, 0xFF, 0xB8, 0xFE, 0x1F, 0x87, 0xE1, 0xF8, 0x7E, 0x1F, 0x87, 0xE1, 0xF8, 0x7E, 0x1F, 0x87, 0xE0, 0x38, 0x0E, 0x03, 0x80, 0xE0, 0x38, 0x0E, 0x03, 0x80, 0xE0, 0x38, 0x0E, 0x03, 0x80, 0xE0, 0x38, 0x0E, 0x03, 0x80, 0xE0, 0x38, 0x0E, 0x03, 0x80, 0xE0, 0x3F, 0xFF, 0xFF, 0xFF, 0x3C, 0x0F, 0x9F, 0x03, 0xE7, 0xC0, 0xF9, 0xF0, 0x3E, 0x7C, 0x0F, 0x9F, 0x87, 0xE7, 0xE1, 0xF9, 0xF8, 0x7E, 0x7E, 0x1F, 0x9F, 0x87, 0xE7, 0x73, 0xB9, 0xDC, 0xEE, 0x77, 0x3B, 0x9D, 0xCE, 0xE7, 0x73, 0xB9, 0xDC, 0xEE, 0x73, 0x33, 0x9C, 0xFC, 0xE7, 0x3F, 0x39, 0xCF, 0xCE, 0x73, 0xF3, 0x9C, 0x7C, 0xFF, 0x1E, 0x3F, 0xC7, 0x8F, 0xE1, 0xF8, 0x7F, 0x1F, 0xC7, 0xF1, 0xFE, 0x7F, 0x9F, 0xE7, 0xF9, 0xFF, 0x7F, 0xDF, 0xB7, 0xED, 0xFB, 0xFE, 0xFF, 0x9F, 0xE7, 0xF9, 0xFE, 0x7F, 0x8F, 0xE3, 0xF8, 0xFE, 0x1F, 0x87, 0x7F, 0xBF, 0xFF, 0xFF, 0x87, 0xE1, 0xF8, 0x7E, 0x1F, 0x87, 0xE1, 0xF8, 0x7E, 0x1F, 0x87, 0xE1, 0xF8, 0x7E, 0x1F, 0x87, 0xE1, 0xF8, 0x7E, 0x1F, 0x87, 0xE1, 0xFF, 0xFF, 0xFD, 0xFE, 0xFF, 0xBF, 0xFF, 0xFF, 0x87, 0xE1, 0xF8, 0x7E, 0x1F, 0x87, 0xE1, 0xF8, 0xFF, 0xFB, 0xFE, 0xFE, 0x38, 0x0E, 0x03, 0x80, 0xE0, 0x38, 0x0E, 0x03, 0x80, 0xE0, 0x38, 0x0E, 0x03, 0x80, 0x7F, 0xBF, 0xFF, 0xFF, 0x87, 0xE1, 0xF8, 0x7E, 0x1F, 0x87, 0xE1, 0xF8, 0x7E, 0x1F, 0x87, 0xE1, 0xF8, 0x7E, 0x1F, 0x87, 0xE1, 0xF8, 0x7E, 0x1F, 0x87, 0xE1, 0xFF, 0xFF, 0xFD, 0xFE, 0x0E, 0x03, 0xC0, 0x70, 0x0C, 0x00, 0x00, 0xFF, 0xBF, 0xFF, 0xFF, 0x87, 0xE1, 0xF8, 0x7E, 0x1F, 0x87, 0xE1, 0xF8, 0xFF, 0xFB, 0xFC, 0xFF, 0xB8, 0xFE, 0x1F, 0x87, 0xE1, 0xF8, 0x7E, 0x1F, 0x87, 0xE1, 0xF8, 0x7E, 0x1F, 0x87, 0x7F, 0xBF, 0xFF, 0xFF, 0x87, 0xE1, 0xF8, 0x7E, 0x1F, 0x87, 0xE0, 0x3C, 0x07, 0xC1, 0xFC, 0x3F, 0x83, 0xE0, 0x7C, 0x07, 0xE1, 0xF8, 0x7E, 0x1F, 0x87, 0xE1, 0xFF, 0xFF, 0xFD, 0xFE, 0xFF, 0xFF, 0xFF, 0xFF, 0x87, 0x00, 0xE0, 0x1C, 0x03, 0x80, 0x70, 0x0E, 0x01, 0xC0, 0x38, 0x07, 0x00, 0xE0, 0x1C, 0x03, 0x80, 0x70, 0x0E, 0x01, 0xC0, 0x38, 0x07, 0x00, 0xE0, 0x1C, 0x03, 0x80, 0x70, 0xE1, 0xF8, 0x7E, 0x1F, 0x87, 0xE1, 0xF8, 0x7E, 0x1F, 0x87, 0xE1, 0xF8, 0x7E, 0x1F, 0x87, 0xE1, 0xF8, 0x7E, 0x1F, 0x87, 0xE1, 0xF8, 0x7E, 0x1F, 0x87, 0xE1, 0xFF, 0xFF, 0xFD, 0xFE, 0xE0, 0xFC, 0x1F, 0x83, 0xF0, 0x7F, 0x1F, 0xE3, 0xFC, 0x73, 0x8E, 0x71, 0xCE, 0x39, 0xC7, 0x3D, 0xE7, 0xBC, 0xF7, 0x0E, 0xE1, 0xDC, 0x3B, 0x87, 0x70, 0xEE, 0x1D, 0xC3, 0xF8, 0x3E, 0x07, 0xC0, 0xF8, 0xE0, 0xF8, 0x3F, 0x83, 0xE0, 0xFE, 0x0F, 0xC3, 0xBC, 0x3F, 0x0E, 0xF0, 0xFC, 0x39, 0xC7, 0xF0, 0xE7, 0x1D, 0xC7, 0x9C, 0x77, 0x1E, 0x71, 0xDC, 0x79, 0xC7, 0x79, 0xC7, 0x9D, 0xE7, 0x1E, 0x73, 0x9C, 0x3B, 0xCE, 0x70, 0xEF, 0x39, 0xC3, 0xB8, 0xEF, 0x0E, 0xE3, 0xBC, 0x3B, 0x8E, 0xE0, 0xEE, 0x3B, 0x83, 0xB8, 0x7E, 0x0F, 0xE1, 0xF8, 0x1F, 0x87, 0xE0, 0x7C, 0x1F, 0x81, 0xF0, 0x7E, 0x07, 0xC1, 0xF0, 0xF0, 0xEF, 0x0E, 0xF1, 0xE7, 0x1E, 0x79, 0xC7, 0x9C, 0x7B, 0xC3, 0xBC, 0x3B, 0x83, 0xF8, 0x3F, 0x81, 0xF8, 0x1F, 0x83, 0xF8, 0x3F, 0x83, 0xB8, 0x3B, 0xC7, 0xBC, 0x79, 0xC7, 0x9C, 0x71, 0xEF, 0x1E, 0xF0, 0xEF, 0x0E, 0xF1, 0xFE, 0x3D, 0xC7, 0xB8, 0xE7, 0x1C, 0xF7, 0x8E, 0xE1, 0xDC, 0x3B, 0x87, 0x70, 0x7C, 0x0F, 0x81, 0xF0, 0x1C, 0x03, 0x80, 0x70, 0x0E, 0x01, 0xC0, 0x38, 0x07, 0x00, 0xE0, 0x1C, 0x03, 0x80, 0x70, 0xFF, 0xFF, 0xFF, 0xE0, 0xE0, 0x70, 0x78, 0x3C, 0x1C, 0x0E, 0x0F, 0x07, 0x83, 0x81, 0xC1, 0xE0, 0xF0, 0x70, 0x38, 0x3C, 0x1E, 0x0E, 0x07, 0x07, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF8, 0xE3, 0x8E, 0x38, 0xE3, 0x8E, 0x38, 0xE3, 0x8E, 0x38, 0xE3, 0x8E, 0x38, 0xE3, 0x8E, 0x38, 0xE3, 0x8E, 0x3F, 0xFF, 0xF0, 0xE1, 0xC3, 0x87, 0x87, 0x0E, 0x1C, 0x38, 0x70, 0xF0, 0xE1, 0xC3, 0x87, 0x0F, 0x0E, 0x1C, 0x38, 0x70, 0xE1, 0xE1, 0xC3, 0x87, 0xFF, 0xFF, 0xC7, 0x1C, 0x71, 0xC7, 0x1C, 0x71, 0xC7, 0x1C, 0x71, 0xC7, 0x1C, 0x71, 0xC7, 0x1C, 0x71, 0xC7, 0x1C, 0x71, 0xFF, 0xFF, 0xF0, 0x0E, 0x03, 0xC0, 0x7C, 0x1F, 0x83, 0xF8, 0xF7, 0x1C, 0xE3, 0x8E, 0xE1, 0xDC, 0x3C, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF8, 0xE6, 0x30, 0x1F, 0x03, 0xE0, 0x7C, 0x0D, 0xC3, 0xB8, 0x77, 0x0E, 0xE1, 0xDC, 0x3B, 0x87, 0x70, 0xEF, 0x3D, 0xE7, 0x9C, 0xE3, 0x9C, 0x73, 0xFE, 0x7F, 0xCF, 0xFF, 0xC7, 0xF8, 0xFE, 0x0F, 0xC1, 0xF8, 0x3F, 0x07, 0xFF, 0xBF, 0xFF, 0xFF, 0x87, 0xE1, 0xF8, 0x7E, 0x1F, 0x87, 0xE1, 0xF8, 0xFF, 0xFB, 0xFC, 0xFF, 0xB8, 0xFE, 0x1F, 0x87, 0xE1, 0xF8, 0x7E, 0x1F, 0x87, 0xE3, 0xFF, 0xEF, 0xFB, 0xF8, 0x7F, 0xBF, 0xFF, 0xFF, 0x87, 0xE1, 0xF8, 0x7E, 0x1F, 0x87, 0xE0, 0x38, 0x0E, 0x03, 0x80, 0xE0, 0x38, 0x0E, 0x03, 0x80, 0xE1, 0xF8, 0x7E, 0x1F, 0x87, 0xE1, 0xFF, 0xFF, 0xFD, 0xFE, 0xFF, 0xBF, 0xEF, 0xFF, 0x87, 0xE1, 0xF8, 0x7E, 0x1F, 0x87, 0xE1, 0xF8, 0x7E, 0x1F, 0x87, 0xE1, 0xF8, 0x7E, 0x1F, 0x87, 0xE1, 0xF8, 0x7E, 0x1F, 0x87, 0xE3, 0xFF, 0xEF, 0xFB, 0xF8, 0xFF, 0xFF, 0xFF, 0xFF, 0x80, 0xE0, 0x38, 0x0E, 0x03, 0x80, 0xE0, 0x38, 0x0F, 0xFF, 0xFF, 0xFF, 0xF8, 0x0E, 0x03, 0x80, 0xE0, 0x38, 0x0E, 0x03, 0x80, 0xE0, 0x3F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x80, 0xE0, 0x38, 0x0E, 0x03, 0x80, 0xE0, 0x38, 0x0F, 0xFF, 0xFF, 0xFF, 0xF8, 0x0E, 0x03, 0x80, 0xE0, 0x38, 0x0E, 0x03, 0x80, 0xE0, 0x38, 0x0E, 0x03, 0x80, 0x7F, 0xBF, 0xFF, 0xFF, 0x87, 0xE1, 0xF8, 0x7E, 0x1F, 0x87, 0xE0, 0x38, 0x0E, 0x7F, 0x9F, 0xE7, 0xF8, 0x7E, 0x1F, 0x87, 0xE1, 0xF8, 0x7E, 0x1F, 0x87, 0xF1, 0xDF, 0xF7, 0xFC, 0x7F, 0xE1, 0xF8, 0x7E, 0x1F, 0x87, 0xE1, 0xF8, 0x7E, 0x1F, 0x87, 0xE1, 0xF8, 0x7F, 0xFF, 0xFF, 0xFF, 0xF8, 0x7E, 0x1F, 0x87, 0xE1, 0xF8, 0x7E, 0x1F, 0x87, 0xE1, 0xF8, 0x7E, 0x1F, 0x87, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x1F, 0xC7, 0xF1, 0xFC, 0x07, 0x01, 0xC0, 0x70, 0x1C, 0x07, 0x01, 0xC0, 0x70, 0x1C, 0x07, 0x01, 0xC0, 0x70, 0x1C, 0x07, 0xE1, 0xF8, 0x7E, 0x1F, 0x87, 0xE1, 0xFF, 0xFF, 0xFD, 0xFE, 0xE1, 0xF8, 0x7E, 0x1F, 0x87, 0xE1, 0xF8, 0x7E, 0x1F, 0x87, 0xE1, 0xF8, 0xFF, 0xFB, 0xFC, 0xFF, 0xB8, 0xFE, 0x1F, 0x87, 0xE1, 0xF8, 0x7E, 0x1F, 0x87, 0xE1, 0xF8, 0x7E, 0x1F, 0x87, 0xE0, 0x38, 0x0E, 0x03, 0x80, 0xE0, 0x38, 0x0E, 0x03, 0x80, 0xE0, 0x38, 0x0E, 0x03, 0x80, 0xE0, 0x38, 0x0E, 0x03, 0x80, 0xE0, 0x38, 0x0E, 0x03, 0x80, 0xE0, 0x3F, 0xFF, 0xFF, 0xFF, 0x3C, 0x0F, 0x9F, 0x03, 0xE7, 0xC0, 0xF9, 0xF0, 0x3E, 0x7C, 0x0F, 0x9F, 0x87, 0xE7, 0xE1, 0xF9, 0xF8, 0x7E, 0x7E, 0x1F, 0x9F, 0x87, 0xE7, 0x73, 0xB9, 0xDC, 0xEE, 0x77, 0x3B, 0x9D, 0xCE, 0xE7, 0x73, 0xB9, 0xDC, 0xEE, 0x73, 0x33, 0x9C, 0xFC, 0xE7, 0x3F, 0x39, 0xCF, 0xCE, 0x73, 0xF3, 0x9C, 0x7C, 0xFF, 0x1E, 0x3F, 0xC7, 0x8F, 0xE1, 0xF8, 0x7F, 0x1F, 0xC7, 0xF1, 0xFE, 0x7F, 0x9F, 0xE7, 0xF9, 0xFF, 0x7F, 0xDF, 0xB7, 0xED, 0xFB, 0xFE, 0xFF, 0x9F, 0xE7, 0xF9, 0xFE, 0x7F, 0x8F, 0xE3, 0xF8, 0xFE, 0x1F, 0x87, 0x7F, 0xBF, 0xFF, 0xFF, 0x87, 0xE1, 0xF8, 0x7E, 0x1F, 0x87, 0xE1, 0xF8, 0x7E, 0x1F, 0x87, 0xE1, 0xF8, 0x7E, 0x1F, 0x87, 0xE1, 0xF8, 0x7E, 0x1F, 0x87, 0xE1, 0xFF, 0xFF, 0xFD, 0xFE, 0xFF, 0xBF, 0xFF, 0xFF, 0x87, 0xE1, 0xF8, 0x7E, 0x1F, 0x87, 0xE1, 0xF8, 0xFF, 0xFB, 0xFE, 0xFE, 0x38, 0x0E, 0x03, 0x80, 0xE0, 0x38, 0x0E, 0x03, 0x80, 0xE0, 0x38, 0x0E, 0x03, 0x80, 0x3F, 0x8F, 0xFB, 0xFF, 0xF0, 0x7E, 0x0F, 0xC1, 0xF8, 0x3F, 0x07, 0xE0, 0xFC, 0x1F, 0x83, 0xF0, 0x7E, 0x0F, 0xC1, 0xF8, 0x3F, 0x07, 0xE0, 0xFC, 0x1F, 0x83, 0xF0, 0x7E, 0x0F, 0xFF, 0xFF, 0xFB, 0xFE, 0x0F, 0x80, 0xF0, 0x1F, 0x01, 0x80, 0xFF, 0xBF, 0xFF, 0xFF, 0x87, 0xE1, 0xF8, 0x7E, 0x1F, 0x87, 0xE1, 0xF8, 0xFF, 0xFB, 0xFC, 0xFF, 0xB8, 0xFE, 0x1F, 0x87, 0xE1, 0xF8, 0x7E, 0x1F, 0x87, 0xE1, 0xF8, 0x7E, 0x1F, 0x87, 0x7F, 0xBF, 0xFF, 0xFF, 0x87, 0xE1, 0xF8, 0x7E, 0x1F, 0x87, 0xE0, 0x3C, 0x07, 0xC1, 0xFC, 0x3F, 0x83, 0xE0, 0x7C, 0x07, 0xE1, 0xF8, 0x7E, 0x1F, 0x87, 0xE1, 0xFF, 0xFF, 0xFD, 0xFE, 0xFF, 0xFF, 0xFF, 0xFF, 0x87, 0x00, 0xE0, 0x1C, 0x03, 0x80, 0x70, 0x0E, 0x01, 0xC0, 0x38, 0x07, 0x00, 0xE0, 0x1C, 0x03, 0x80, 0x70, 0x0E, 0x01, 0xC0, 0x38, 0x07, 0x00, 0xE0, 0x1C, 0x03, 0x80, 0x70, 0xE1, 0xF8, 0x7E, 0x1F, 0x87, 0xE1, 0xF8, 0x7E, 0x1F, 0x87, 0xE1, 0xF8, 0x7E, 0x1F, 0x87, 0xE1, 0xF8, 0x7E, 0x1F, 0x87, 0xE1, 0xF8, 0x7E, 0x1F, 0x87, 0xE1, 0xFF, 0xFF, 0xFD, 0xFE, 0xE0, 0xFC, 0x1F, 0x83, 0xF0, 0x7F, 0x1F, 0xE3, 0xFC, 0x73, 0x8E, 0x71, 0xCE, 0x39, 0xC7, 0x3D, 0xE7, 0xBC, 0xF7, 0x0E, 0xE1, 0xDC, 0x3B, 0x87, 0x70, 0xEE, 0x1D, 0xC3, 0xF8, 0x3E, 0x07, 0xC0, 0xF8, 0xE0, 0xF8, 0x3F, 0x83, 0xE0, 0xFE, 0x0F, 0xC3, 0xBC, 0x3F, 0x0E, 0xF0, 0xFC, 0x39, 0xC7, 0xF0, 0xE7, 0x1D, 0xC7, 0x9C, 0x77, 0x1E, 0x71, 0xDC, 0x79, 0xC7, 0x79, 0xC7, 0x9D, 0xE7, 0x1E, 0x73, 0x9C, 0x3B, 0xCE, 0x70, 0xEF, 0x39, 0xC3, 0xB8, 0xEF, 0x0E, 0xE3, 0xBC, 0x3B, 0x8E, 0xE0, 0xEE, 0x3B, 0x83, 0xB8, 0x7E, 0x0F, 0xE1, 0xF8, 0x1F, 0x87, 0xE0, 0x7C, 0x1F, 0x81, 0xF0, 0x7E, 0x07, 0xC1, 0xF0, 0xF0, 0xEF, 0x0E, 0xF1, 0xE7, 0x1E, 0x79, 0xC7, 0x9C, 0x7B, 0xC3, 0xBC, 0x3B, 0x83, 0xF8, 0x3F, 0x81, 0xF8, 0x1F, 0x83, 0xF8, 0x3F, 0x83, 0xB8, 0x3B, 0xC7, 0xBC, 0x79, 0xC7, 0x9C, 0x71, 0xEF, 0x1E, 0xF0, 0xEF, 0x0E, 0xF1, 0xFE, 0x3D, 0xC7, 0xB8, 0xE7, 0x1C, 0xF7, 0x8E, 0xE1, 0xDC, 0x3B, 0x87, 0x70, 0x7C, 0x0F, 0x81, 0xF0, 0x1C, 0x03, 0x80, 0x70, 0x0E, 0x01, 0xC0, 0x38, 0x07, 0x00, 0xE0, 0x1C, 0x03, 0x80, 0x70, 0xFF, 0xFF, 0xFF, 0xE0, 0xE0, 0x70, 0x78, 0x3C, 0x1C, 0x0E, 0x0F, 0x07, 0x83, 0x81, 0xC1, 0xE0, 0xF0, 0x70, 0x38, 0x3C, 0x1E, 0x0E, 0x07, 0x07, 0xFF, 0xFF, 0xFF, 0x03, 0x87, 0xC3, 0xE3, 0xC1, 0xC0, 0xE0, 0x70, 0x38, 0x1C, 0x0E, 0x07, 0x03, 0x83, 0xC7, 0xC3, 0xC1, 0xE0, 0x38, 0x0E, 0x07, 0x03, 0x81, 0xC0, 0xE0, 0x70, 0x38, 0x1C, 0x0E, 0x07, 0x81, 0xF0, 0xF8, 0x1C, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xE0, 0x3E, 0x0F, 0x80, 0xF0, 0x1C, 0x07, 0x01, 0xC0, 0x70, 0x1C, 0x07, 0x01, 0xC0, 0x70, 0x1E, 0x03, 0xF0, 0x7C, 0x3F, 0x1E, 0x07, 0x01, 0xC0, 0x70, 0x1C, 0x07, 0x01, 0xC0, 0x70, 0x1C, 0x07, 0x03, 0xC3, 0xE0, 0xF8, 0x38, 0x00, 0x3C, 0x07, 0xFC, 0x3F, 0xFF, 0xF1, 0xFF, 0x81, 0xF0 }; const GFXglyph Chosence_Bold16pt7bGlyphs[] PROGMEM = { { 0, 0, 0, 7, 0, 1 }, // 0x20 ' ' { 0, 4, 24, 8, 2, -23 }, // 0x21 '!' { 12, 8, 9, 12, 2, -23 }, // 0x22 '"' { 21, 14, 24, 16, 1, -23 }, // 0x23 '#' { 63, 11, 30, 15, 2, -26 }, // 0x24 '$' { 105, 19, 24, 21, 1, -23 }, // 0x25 '%' { 162, 18, 24, 18, 1, -23 }, // 0x26 '&' { 216, 3, 9, 6, 2, -23 }, // 0x27 ''' { 220, 6, 30, 9, 2, -26 }, // 0x28 '(' { 243, 5, 30, 9, 1, -26 }, // 0x29 ')' { 262, 11, 11, 12, 1, -23 }, // 0x2A '*' { 278, 13, 13, 13, 0, -17 }, // 0x2B '+' { 300, 4, 9, 6, 1, -3 }, // 0x2C ',' { 305, 10, 3, 12, 1, -12 }, // 0x2D '-' { 309, 4, 4, 6, 1, -3 }, // 0x2E '.' { 311, 7, 24, 9, 1, -23 }, // 0x2F '/' { 332, 10, 24, 14, 2, -23 }, // 0x30 '0' { 362, 11, 24, 13, 1, -23 }, // 0x31 '1' { 395, 10, 24, 14, 2, -23 }, // 0x32 '2' { 425, 10, 24, 14, 2, -23 }, // 0x33 '3' { 455, 12, 24, 14, 1, -23 }, // 0x34 '4' { 491, 10, 24, 13, 2, -23 }, // 0x35 '5' { 521, 10, 24, 14, 2, -23 }, // 0x36 '6' { 551, 11, 24, 13, 1, -23 }, // 0x37 '7' { 584, 10, 24, 15, 2, -23 }, // 0x38 '8' { 614, 10, 24, 14, 2, -23 }, // 0x39 '9' { 644, 4, 16, 6, 1, -18 }, // 0x3A ':' { 652, 4, 24, 6, 1, -18 }, // 0x3B ';' { 664, 13, 14, 14, 1, -18 }, // 0x3C '<' { 687, 13, 8, 15, 1, -15 }, // 0x3D '=' { 700, 13, 14, 14, 1, -18 }, // 0x3E '>' { 723, 10, 24, 12, 1, -23 }, // 0x3F '?' { 753, 20, 24, 24, 2, -23 }, // 0x40 '@' { 813, 11, 24, 13, 1, -23 }, // 0x41 'A' { 846, 10, 24, 14, 2, -23 }, // 0x42 'B' { 876, 10, 24, 14, 2, -23 }, // 0x43 'C' { 906, 10, 24, 14, 2, -23 }, // 0x44 'D' { 936, 10, 24, 13, 2, -23 }, // 0x45 'E' { 966, 10, 24, 12, 2, -23 }, // 0x46 'F' { 996, 10, 24, 14, 2, -23 }, // 0x47 'G' { 1026, 10, 24, 14, 2, -23 }, // 0x48 'H' { 1056, 3, 24, 7, 2, -23 }, // 0x49 'I' { 1065, 10, 24, 13, 1, -23 }, // 0x4A 'J' { 1095, 10, 24, 14, 2, -23 }, // 0x4B 'K' { 1125, 10, 24, 12, 2, -23 }, // 0x4C 'L' { 1155, 18, 24, 21, 1, -23 }, // 0x4D 'M' { 1209, 10, 24, 14, 2, -23 }, // 0x4E 'N' { 1239, 10, 24, 14, 2, -23 }, // 0x4F 'O' { 1269, 10, 24, 13, 2, -23 }, // 0x50 'P' { 1299, 10, 29, 15, 2, -23 }, // 0x51 'Q' { 1336, 10, 24, 14, 2, -23 }, // 0x52 'R' { 1366, 10, 24, 13, 1, -23 }, // 0x53 'S' { 1396, 11, 24, 12, 0, -23 }, // 0x54 'T' { 1429, 10, 24, 14, 2, -23 }, // 0x55 'U' { 1459, 11, 24, 14, 1, -23 }, // 0x56 'V' { 1492, 22, 24, 24, 1, -23 }, // 0x57 'W' { 1558, 12, 24, 14, 1, -23 }, // 0x58 'X' { 1594, 11, 24, 11, 0, -23 }, // 0x59 'Y' { 1627, 9, 24, 11, 1, -23 }, // 0x5A 'Z' { 1654, 6, 30, 8, 1, -26 }, // 0x5B '[' { 1677, 7, 24, 11, 2, -23 }, // 0x5C '\' { 1698, 6, 30, 8, 1, -26 }, // 0x5D ']' { 1721, 11, 10, 14, 2, -23 }, // 0x5E '^' { 1735, 15, 3, 17, 1, 2 }, // 0x5F '_' { 1741, 4, 3, 7, 2, -27 }, // 0x60 '`' { 1743, 11, 24, 13, 1, -23 }, // 0x61 'a' { 1776, 10, 24, 14, 2, -23 }, // 0x62 'b' { 1806, 10, 24, 14, 2, -23 }, // 0x63 'c' { 1836, 10, 24, 14, 2, -23 }, // 0x64 'd' { 1866, 10, 24, 13, 2, -23 }, // 0x65 'e' { 1896, 10, 24, 12, 2, -23 }, // 0x66 'f' { 1926, 10, 24, 14, 2, -23 }, // 0x67 'g' { 1956, 10, 24, 14, 2, -23 }, // 0x68 'h' { 1986, 3, 24, 7, 2, -23 }, // 0x69 'i' { 1995, 10, 24, 13, 1, -23 }, // 0x6A 'j' { 2025, 10, 24, 14, 2, -23 }, // 0x6B 'k' { 2055, 10, 24, 12, 2, -23 }, // 0x6C 'l' { 2085, 18, 24, 21, 1, -23 }, // 0x6D 'm' { 2139, 10, 24, 14, 2, -23 }, // 0x6E 'n' { 2169, 10, 24, 14, 2, -23 }, // 0x6F 'o' { 2199, 10, 24, 13, 2, -23 }, // 0x70 'p' { 2229, 11, 28, 15, 2, -23 }, // 0x71 'q' { 2268, 10, 24, 14, 2, -23 }, // 0x72 'r' { 2298, 10, 24, 13, 1, -23 }, // 0x73 's' { 2328, 11, 24, 12, 0, -23 }, // 0x74 't' { 2361, 10, 24, 14, 2, -23 }, // 0x75 'u' { 2391, 11, 24, 14, 1, -23 }, // 0x76 'v' { 2424, 22, 24, 24, 1, -23 }, // 0x77 'w' { 2490, 12, 24, 14, 1, -23 }, // 0x78 'x' { 2526, 11, 24, 11, 0, -23 }, // 0x79 'y' { 2559, 9, 24, 11, 1, -23 }, // 0x7A 'z' { 2586, 9, 30, 11, 1, -26 }, // 0x7B '{' { 2620, 3, 32, 7, 2, -25 }, // 0x7C '|' { 2632, 10, 30, 12, 1, -26 }, // 0x7D '}' { 2670, 14, 5, 16, 1, -13 } }; // 0x7E '~' const GFXfont Chosence_Bold16pt7b PROGMEM = { (uint8_t *)Chosence_Bold16pt7bBitmaps, (GFXglyph *)Chosence_Bold16pt7bGlyphs, 0x20, 0x7E, 36 }; // Approx. 3351 bytesчета не туда попадают номера строк вот файл
/* 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 "Adafruit_GFX.h" #include "glcdfont.c" #ifdef __AVR__ #include <avr/pgmspace.h> #elif defined(ESP8266) || defined(ESP32) #include <pgmspace.h> #endif // Many (but maybe not all) non-AVR board installs define macros // for compatibility with existing PROGMEM-reading AVR code. // Do our own checks and defines here for good measure... #ifndef pgm_read_byte #define pgm_read_byte(addr) (*(const unsigned char *)(addr)) #endif #ifndef pgm_read_word #define pgm_read_word(addr) (*(const unsigned short *)(addr)) #endif #ifndef pgm_read_dword #define pgm_read_dword(addr) (*(const unsigned long *)(addr)) #endif // Pointers are a peculiar case...typically 16-bit on AVR boards, // 32 bits elsewhere. Try to accommodate both... #if !defined(__INT_MAX__) || (__INT_MAX__ > 0xFFFF) #define pgm_read_pointer(addr) ((void *)pgm_read_dword(addr)) #else #define pgm_read_pointer(addr) ((void *)pgm_read_word(addr)) #endif #ifndef min #define min(a,b) (((a) < (b)) ? (a) : (b)) #endif #ifndef _swap_int16_t #define _swap_int16_t(a, b) { int16_t t = a; a = b; b = t; } #endif /**************************************************************************/ /*! @brief Instatiate a GFX context for graphics! Can only be done by a superclass @param w Display width, in pixels @param h Display height, in pixels */ /**************************************************************************/ Adafruit_GFX::Adafruit_GFX(int16_t w, int16_t h): WIDTH(w), HEIGHT(h) { _width = WIDTH; _height = HEIGHT; rotation = 0; cursor_y = cursor_x = 0; textsize = 1; textcolor = textbgcolor = 0xFFFF; wrap = true; _cp437 = false; gfxFont = NULL; } /**************************************************************************/ /*! @brief Write a line. Bresenham's algorithm - thx wikpedia @param x0 Start point x coordinate @param y0 Start point y coordinate @param x1 End point x coordinate @param y1 End point y coordinate @param color 16-bit 5-6-5 Color to draw with */ /**************************************************************************/ void Adafruit_GFX::writeLine(int16_t x0, int16_t y0, int16_t x1, int16_t y1, uint16_t color) { #if defined(ESP8266) yield(); #endif int16_t steep = abs(y1 - y0) > abs(x1 - x0); if (steep) { _swap_int16_t(x0, y0); _swap_int16_t(x1, y1); } if (x0 > x1) { _swap_int16_t(x0, x1); _swap_int16_t(y0, y1); } int16_t dx, dy; dx = x1 - x0; dy = abs(y1 - y0); int16_t err = dx / 2; int16_t ystep; if (y0 < y1) { ystep = 1; } else { ystep = -1; } for (; x0<=x1; x0++) { if (steep) { writePixel(y0, x0, color); } else { writePixel(x0, y0, color); } err -= dy; if (err < 0) { y0 += ystep; err += dx; } } } /**************************************************************************/ /*! @brief Start a display-writing routine, overwrite in subclasses. */ /**************************************************************************/ void Adafruit_GFX::startWrite(){ } /**************************************************************************/ /*! @brief Write a pixel, overwrite in subclasses if startWrite is defined! @param x x coordinate @param y y coordinate @param color 16-bit 5-6-5 Color to fill with */ /**************************************************************************/ void Adafruit_GFX::writePixel(int16_t x, int16_t y, uint16_t color){ drawPixel(x, y, color); } /**************************************************************************/ /*! @brief Write a perfectly vertical line, overwrite in subclasses if startWrite is defined! @param x Top-most x coordinate @param y Top-most y coordinate @param h Height in pixels @param color 16-bit 5-6-5 Color to fill with */ /**************************************************************************/ void Adafruit_GFX::writeFastVLine(int16_t x, int16_t y, int16_t h, uint16_t color) { // Overwrite in subclasses if startWrite is defined! // Can be just writeLine(x, y, x, y+h-1, color); // or writeFillRect(x, y, 1, h, color); drawFastVLine(x, y, h, color); } /**************************************************************************/ /*! @brief Write a perfectly horizontal line, overwrite in subclasses if startWrite is defined! @param x Left-most x coordinate @param y Left-most y coordinate @param w Width in pixels @param color 16-bit 5-6-5 Color to fill with */ /**************************************************************************/ void Adafruit_GFX::writeFastHLine(int16_t x, int16_t y, int16_t w, uint16_t color) { // Overwrite in subclasses if startWrite is defined! // Example: writeLine(x, y, x+w-1, y, color); // or writeFillRect(x, y, w, 1, color); drawFastHLine(x, y, w, color); } /**************************************************************************/ /*! @brief Write a rectangle completely with one color, overwrite in subclasses if startWrite is defined! @param x Top left corner x coordinate @param y Top left corner y coordinate @param w Width in pixels @param h Height in pixels @param color 16-bit 5-6-5 Color to fill with */ /**************************************************************************/ void Adafruit_GFX::writeFillRect(int16_t x, int16_t y, int16_t w, int16_t h, uint16_t color) { // Overwrite in subclasses if desired! fillRect(x,y,w,h,color); } /**************************************************************************/ /*! @brief End a display-writing routine, overwrite in subclasses if startWrite is defined! */ /**************************************************************************/ void Adafruit_GFX::endWrite(){ } /**************************************************************************/ /*! @brief Draw a perfectly vertical line (this is often optimized in a subclass!) @param x Top-most x coordinate @param y Top-most y coordinate @param h Height in pixels @param color 16-bit 5-6-5 Color to fill with */ /**************************************************************************/ void Adafruit_GFX::drawFastVLine(int16_t x, int16_t y, int16_t h, uint16_t color) { startWrite(); writeLine(x, y, x, y+h-1, color); endWrite(); } /**************************************************************************/ /*! @brief Draw a perfectly horizontal line (this is often optimized in a subclass!) @param x Left-most x coordinate @param y Left-most y coordinate @param w Width in pixels @param color 16-bit 5-6-5 Color to fill with */ /**************************************************************************/ void Adafruit_GFX::drawFastHLine(int16_t x, int16_t y, int16_t w, uint16_t color) { startWrite(); writeLine(x, y, x+w-1, y, color); endWrite(); } /**************************************************************************/ /*! @brief Fill a rectangle completely with one color. Update in subclasses if desired! @param x Top left corner x coordinate @param y Top left corner y coordinate @param w Width in pixels @param h Height in pixels @param color 16-bit 5-6-5 Color to fill with */ /**************************************************************************/ void Adafruit_GFX::fillRect(int16_t x, int16_t y, int16_t w, int16_t h, uint16_t color) { startWrite(); for (int16_t i=x; i<x+w; i++) { writeFastVLine(i, y, h, color); } endWrite(); } /**************************************************************************/ /*! @brief Fill the screen completely with one color. Update in subclasses if desired! @param color 16-bit 5-6-5 Color to fill with */ /**************************************************************************/ void Adafruit_GFX::fillScreen(uint16_t color) { fillRect(0, 0, _width, _height, color); } /**************************************************************************/ /*! @brief Draw a line @param x0 Start point x coordinate @param y0 Start point y coordinate @param x1 End point x coordinate @param y1 End point y coordinate @param color 16-bit 5-6-5 Color to draw with */ /**************************************************************************/ void Adafruit_GFX::drawLine(int16_t x0, int16_t y0, int16_t x1, int16_t y1, uint16_t color) { // Update in subclasses if desired! if(x0 == x1){ if(y0 > y1) _swap_int16_t(y0, y1); drawFastVLine(x0, y0, y1 - y0 + 1, color); } else if(y0 == y1){ if(x0 > x1) _swap_int16_t(x0, x1); drawFastHLine(x0, y0, x1 - x0 + 1, color); } else { startWrite(); writeLine(x0, y0, x1, y1, color); endWrite(); } } /**************************************************************************/ /*! @brief Draw a circle outline @param x0 Center-point x coordinate @param y0 Center-point y coordinate @param r Radius of circle @param color 16-bit 5-6-5 Color to draw with */ /**************************************************************************/ void Adafruit_GFX::drawCircle(int16_t x0, int16_t y0, int16_t r, uint16_t color) { #if defined(ESP8266) yield(); #endif int16_t f = 1 - r; int16_t ddF_x = 1; int16_t ddF_y = -2 * r; int16_t x = 0; int16_t y = r; startWrite(); writePixel(x0 , y0+r, color); writePixel(x0 , y0-r, color); writePixel(x0+r, y0 , color); writePixel(x0-r, y0 , color); while (x<y) { if (f >= 0) { y--; ddF_y += 2; f += ddF_y; } x++; ddF_x += 2; f += ddF_x; writePixel(x0 + x, y0 + y, color); writePixel(x0 - x, y0 + y, color); writePixel(x0 + x, y0 - y, color); writePixel(x0 - x, y0 - y, color); writePixel(x0 + y, y0 + x, color); writePixel(x0 - y, y0 + x, color); writePixel(x0 + y, y0 - x, color); writePixel(x0 - y, y0 - x, color); } endWrite(); } /**************************************************************************/ /*! @brief Quarter-circle drawer, used to do circles and roundrects @param x0 Center-point x coordinate @param y0 Center-point y coordinate @param r Radius of circle @param cornername Mask bit #1 or bit #2 to indicate which quarters of the circle we're doing @param color 16-bit 5-6-5 Color to draw with */ /**************************************************************************/ 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) { writePixel(x0 + x, y0 + y, color); writePixel(x0 + y, y0 + x, color); } if (cornername & 0x2) { writePixel(x0 + x, y0 - y, color); writePixel(x0 + y, y0 - x, color); } if (cornername & 0x8) { writePixel(x0 - y, y0 + x, color); writePixel(x0 - x, y0 + y, color); } if (cornername & 0x1) { writePixel(x0 - y, y0 - x, color); writePixel(x0 - x, y0 - y, color); } } } /**************************************************************************/ /*! @brief Draw a circle with filled color @param x0 Center-point x coordinate @param y0 Center-point y coordinate @param r Radius of circle @param color 16-bit 5-6-5 Color to fill with */ /**************************************************************************/ void Adafruit_GFX::fillCircle(int16_t x0, int16_t y0, int16_t r, uint16_t color) { startWrite(); writeFastVLine(x0, y0-r, 2*r+1, color); fillCircleHelper(x0, y0, r, 3, 0, color); endWrite(); } /**************************************************************************/ /*! @brief Quarter-circle drawer with fill, used for circles and roundrects @param x0 Center-point x coordinate @param y0 Center-point y coordinate @param r Radius of circle @param corners Mask bits indicating which quarters we're doing @param delta Offset from center-point, used for round-rects @param color 16-bit 5-6-5 Color to fill with */ /**************************************************************************/ void Adafruit_GFX::fillCircleHelper(int16_t x0, int16_t y0, int16_t r, uint8_t corners, 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; int16_t px = x; int16_t py = y; delta++; // Avoid some +1's in the loop while(x < y) { if (f >= 0) { y--; ddF_y += 2; f += ddF_y; } x++; ddF_x += 2; f += ddF_x; // These checks avoid double-drawing certain lines, important // for the SSD1306 library which has an INVERT drawing mode. if(x < (y + 1)) { if(corners & 1) writeFastVLine(x0+x, y0-y, 2*y+delta, color); if(corners & 2) writeFastVLine(x0-x, y0-y, 2*y+delta, color); } if(y != py) { if(corners & 1) writeFastVLine(x0+py, y0-px, 2*px+delta, color); if(corners & 2) writeFastVLine(x0-py, y0-px, 2*px+delta, color); py = y; } px = x; } } /**************************************************************************/ /*! @brief Draw a rectangle with no fill color @param x Top left corner x coordinate @param y Top left corner y coordinate @param w Width in pixels @param h Height in pixels @param color 16-bit 5-6-5 Color to draw with */ /**************************************************************************/ void Adafruit_GFX::drawRect(int16_t x, int16_t y, int16_t w, int16_t h, uint16_t color) { startWrite(); writeFastHLine(x, y, w, color); writeFastHLine(x, y+h-1, w, color); writeFastVLine(x, y, h, color); writeFastVLine(x+w-1, y, h, color); endWrite(); } /**************************************************************************/ /*! @brief Draw a rounded rectangle with no fill color @param x Top left corner x coordinate @param y Top left corner y coordinate @param w Width in pixels @param h Height in pixels @param r Radius of corner rounding @param color 16-bit 5-6-5 Color to draw with */ /**************************************************************************/ void Adafruit_GFX::drawRoundRect(int16_t x, int16_t y, int16_t w, int16_t h, int16_t r, uint16_t color) { int16_t max_radius = ((w < h) ? w : h) / 2; // 1/2 minor axis if(r > max_radius) r = max_radius; // smarter version startWrite(); writeFastHLine(x+r , y , w-2*r, color); // Top writeFastHLine(x+r , y+h-1, w-2*r, color); // Bottom writeFastVLine(x , y+r , h-2*r, color); // Left writeFastVLine(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); endWrite(); } /**************************************************************************/ /*! @brief Draw a rounded rectangle with fill color @param x Top left corner x coordinate @param y Top left corner y coordinate @param w Width in pixels @param h Height in pixels @param r Radius of corner rounding @param color 16-bit 5-6-5 Color to draw/fill with */ /**************************************************************************/ void Adafruit_GFX::fillRoundRect(int16_t x, int16_t y, int16_t w, int16_t h, int16_t r, uint16_t color) { int16_t max_radius = ((w < h) ? w : h) / 2; // 1/2 minor axis if(r > max_radius) r = max_radius; // smarter version startWrite(); writeFillRect(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); endWrite(); } /**************************************************************************/ /*! @brief Draw a triangle with no fill color @param x0 Vertex #0 x coordinate @param y0 Vertex #0 y coordinate @param x1 Vertex #1 x coordinate @param y1 Vertex #1 y coordinate @param x2 Vertex #2 x coordinate @param y2 Vertex #2 y coordinate @param color 16-bit 5-6-5 Color to draw with */ /**************************************************************************/ 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); } /**************************************************************************/ /*! @brief Draw a triangle with color-fill @param x0 Vertex #0 x coordinate @param y0 Vertex #0 y coordinate @param x1 Vertex #1 x coordinate @param y1 Vertex #1 y coordinate @param x2 Vertex #2 x coordinate @param y2 Vertex #2 y coordinate @param color 16-bit 5-6-5 Color to fill/draw with */ /**************************************************************************/ void Adafruit_GFX::fillTriangle(int16_t x0, int16_t y0, int16_t x1, int16_t y1, int16_t x2, int16_t y2, uint16_t color) { int16_t a, b, y, last; // Sort coordinates by Y order (y2 >= y1 >= y0) if (y0 > y1) { _swap_int16_t(y0, y1); _swap_int16_t(x0, x1); } if (y1 > y2) { _swap_int16_t(y2, y1); _swap_int16_t(x2, x1); } if (y0 > y1) { _swap_int16_t(y0, y1); _swap_int16_t(x0, x1); } startWrite(); 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; writeFastHLine(a, y0, b-a+1, color); endWrite(); return; } int16_t dx01 = x1 - x0, dy01 = y1 - y0, dx02 = x2 - x0, dy02 = y2 - y0, dx12 = x2 - x1, dy12 = y2 - y1; int32_t sa = 0, sb = 0; // For upper part of triangle, find scanline crossings for segments // 0-1 and 0-2. If y1=y2 (flat-bottomed triangle), the scanline y1 // is included here (and second loop will be skipped, avoiding a /0 // error there), otherwise scanline y1 is skipped here and handled // in the second loop...which also avoids a /0 error here if y0=y1 // (flat-topped triangle). if(y1 == y2) last = y1; // Include y1 scanline else last = y1-1; // Skip it for(y=y0; y<=last; y++) { a = x0 + sa / dy01; b = x0 + sb / dy02; sa += dx01; sb += dx02; /* longhand: a = x0 + (x1 - x0) * (y - y0) / (y1 - y0); b = x0 + (x2 - x0) * (y - y0) / (y2 - y0); */ if(a > b) _swap_int16_t(a,b); writeFastHLine(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 = (int32_t)dx12 * (y - y1); sb = (int32_t)dx02 * (y - y0); for(; y<=y2; y++) { a = x1 + sa / dy12; b = x0 + sb / dy02; sa += dx12; sb += dx02; /* longhand: a = x1 + (x2 - x1) * (y - y1) / (y2 - y1); b = x0 + (x2 - x0) * (y - y0) / (y2 - y0); */ if(a > b) _swap_int16_t(a,b); writeFastHLine(a, y, b-a+1, color); } endWrite(); } // BITMAP / XBITMAP / GRAYSCALE / RGB BITMAP FUNCTIONS --------------------- /**************************************************************************/ /*! @brief Draw a PROGMEM-resident 1-bit image at the specified (x,y) position, using the specified foreground color (unset bits are transparent). @param x Top left corner x coordinate @param y Top left corner y coordinate @param bitmap byte array with monochrome bitmap @param w Width of bitmap in pixels @param h Height of bitmap in pixels @param color 16-bit 5-6-5 Color to draw with */ /**************************************************************************/ 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 byteWidth = (w + 7) / 8; // Bitmap scanline pad = whole byte uint8_t byte = 0; startWrite(); for(int16_t j=0; j<h; j++, y++) { for(int16_t i=0; i<w; i++) { if(i & 7) byte <<= 1; else byte = pgm_read_byte(&bitmap[j * byteWidth + i / 8]); if(byte & 0x80) writePixel(x+i, y, color); } } endWrite(); } /**************************************************************************/ /*! @brief Draw a PROGMEM-resident 1-bit image at the specified (x,y) position, using the specified foreground (for set bits) and background (unset bits) colors. @param x Top left corner x coordinate @param y Top left corner y coordinate @param bitmap byte array with monochrome bitmap @param w Width of bitmap in pixels @param h Height of bitmap in pixels @param color 16-bit 5-6-5 Color to draw pixels with @param bg 16-bit 5-6-5 Color to draw background with */ /**************************************************************************/ void Adafruit_GFX::drawBitmap(int16_t x, int16_t y, const uint8_t bitmap[], int16_t w, int16_t h, uint16_t color, uint16_t bg) { int16_t byteWidth = (w + 7) / 8; // Bitmap scanline pad = whole byte uint8_t byte = 0; startWrite(); for(int16_t j=0; j<h; j++, y++) { for(int16_t i=0; i<w; i++ ) { if(i & 7) byte <<= 1; else byte = pgm_read_byte(&bitmap[j * byteWidth + i / 8]); writePixel(x+i, y, (byte & 0x80) ? color : bg); } } endWrite(); } /**************************************************************************/ /*! @brief Draw a RAM-resident 1-bit image at the specified (x,y) position, using the specified foreground color (unset bits are transparent). @param x Top left corner x coordinate @param y Top left corner y coordinate @param bitmap byte array with monochrome bitmap @param w Width of bitmap in pixels @param h Height of bitmap in pixels @param color 16-bit 5-6-5 Color to draw with */ /**************************************************************************/ void Adafruit_GFX::drawBitmap(int16_t x, int16_t y, uint8_t *bitmap, int16_t w, int16_t h, uint16_t color) { int16_t byteWidth = (w + 7) / 8; // Bitmap scanline pad = whole byte uint8_t byte = 0; startWrite(); for(int16_t j=0; j<h; j++, y++) { for(int16_t i=0; i<w; i++ ) { if(i & 7) byte <<= 1; else byte = bitmap[j * byteWidth + i / 8]; if(byte & 0x80) writePixel(x+i, y, color); } } endWrite(); } /**************************************************************************/ /*! @brief Draw a RAM-resident 1-bit image at the specified (x,y) position, using the specified foreground (for set bits) and background (unset bits) colors. @param x Top left corner x coordinate @param y Top left corner y coordinate @param bitmap byte array with monochrome bitmap @param w Width of bitmap in pixels @param h Height of bitmap in pixels @param color 16-bit 5-6-5 Color to draw pixels with @param bg 16-bit 5-6-5 Color to draw background with */ /**************************************************************************/ void Adafruit_GFX::drawBitmap(int16_t x, int16_t y, uint8_t *bitmap, int16_t w, int16_t h, uint16_t color, uint16_t bg) { int16_t byteWidth = (w + 7) / 8; // Bitmap scanline pad = whole byte uint8_t byte = 0; startWrite(); for(int16_t j=0; j<h; j++, y++) { for(int16_t i=0; i<w; i++ ) { if(i & 7) byte <<= 1; else byte = bitmap[j * byteWidth + i / 8]; writePixel(x+i, y, (byte & 0x80) ? color : bg); } } endWrite(); } /**************************************************************************/ /*! @brief Draw PROGMEM-resident XBitMap Files (*.xbm), exported from GIMP. Usage: Export from GIMP to *.xbm, rename *.xbm to *.c and open in editor. C Array can be directly used with this function. There is no RAM-resident version of this function; if generating bitmaps in RAM, use the format defined by drawBitmap() and call that instead. @param x Top left corner x coordinate @param y Top left corner y coordinate @param bitmap byte array with monochrome bitmap @param w Width of bitmap in pixels @param h Height of bitmap in pixels @param color 16-bit 5-6-5 Color to draw pixels with */ /**************************************************************************/ void Adafruit_GFX::drawXBitmap(int16_t x, int16_t y, const uint8_t bitmap[], int16_t w, int16_t h, uint16_t color) { int16_t byteWidth = (w + 7) / 8; // Bitmap scanline pad = whole byte uint8_t byte = 0; startWrite(); for(int16_t j=0; j<h; j++, y++) { for(int16_t i=0; i<w; i++ ) { if(i & 7) byte >>= 1; else byte = pgm_read_byte(&bitmap[j * byteWidth + i / 8]); // Nearly identical to drawBitmap(), only the bit order // is reversed here (left-to-right = LSB to MSB): if(byte & 0x01) writePixel(x+i, y, color); } } endWrite(); } /**************************************************************************/ /*! @brief Draw a PROGMEM-resident 8-bit image (grayscale) at the specified (x,y) pos. Specifically for 8-bit display devices such as IS31FL3731; no color reduction/expansion is performed. @param x Top left corner x coordinate @param y Top left corner y coordinate @param bitmap byte array with grayscale bitmap @param w Width of bitmap in pixels @param h Height of bitmap in pixels */ /**************************************************************************/ void Adafruit_GFX::drawGrayscaleBitmap(int16_t x, int16_t y, const uint8_t bitmap[], int16_t w, int16_t h) { startWrite(); for(int16_t j=0; j<h; j++, y++) { for(int16_t i=0; i<w; i++ ) { writePixel(x+i, y, (uint8_t)pgm_read_byte(&bitmap[j * w + i])); } } endWrite(); } /**************************************************************************/ /*! @brief Draw a RAM-resident 8-bit image (grayscale) at the specified (x,y) pos. Specifically for 8-bit display devices such as IS31FL3731; no color reduction/expansion is performed. @param x Top left corner x coordinate @param y Top left corner y coordinate @param bitmap byte array with grayscale bitmap @param w Width of bitmap in pixels @param h Height of bitmap in pixels */ /**************************************************************************/ void Adafruit_GFX::drawGrayscaleBitmap(int16_t x, int16_t y, uint8_t *bitmap, int16_t w, int16_t h) { startWrite(); for(int16_t j=0; j<h; j++, y++) { for(int16_t i=0; i<w; i++ ) { writePixel(x+i, y, bitmap[j * w + i]); } } endWrite(); } /**************************************************************************/ /*! @brief Draw a PROGMEM-resident 8-bit image (grayscale) with a 1-bit mask (set bits = opaque, unset bits = clear) at the specified (x,y) position. BOTH buffers (grayscale and mask) must be PROGMEM-resident. Specifically for 8-bit display devices such as IS31FL3731; no color reduction/expansion is performed. @param x Top left corner x coordinate @param y Top left corner y coordinate @param bitmap byte array with grayscale bitmap @param mask byte array with mask bitmap @param w Width of bitmap in pixels @param h Height of bitmap in pixels */ /**************************************************************************/ void Adafruit_GFX::drawGrayscaleBitmap(int16_t x, int16_t y, const uint8_t bitmap[], const uint8_t mask[], int16_t w, int16_t h) { int16_t bw = (w + 7) / 8; // Bitmask scanline pad = whole byte uint8_t byte = 0; startWrite(); for(int16_t j=0; j<h; j++, y++) { for(int16_t i=0; i<w; i++ ) { if(i & 7) byte <<= 1; else byte = pgm_read_byte(&mask[j * bw + i / 8]); if(byte & 0x80) { writePixel(x+i, y, (uint8_t)pgm_read_byte(&bitmap[j * w + i])); } } } endWrite(); } /**************************************************************************/ /*! @brief Draw a RAM-resident 8-bit image (grayscale) with a 1-bit mask (set bits = opaque, unset bits = clear) at the specified (x,y) position. BOTH buffers (grayscale and mask) must be RAM-residentt, no mix-and-match Specifically for 8-bit display devices such as IS31FL3731; no color reduction/expansion is performed. @param x Top left corner x coordinate @param y Top left corner y coordinate @param bitmap byte array with grayscale bitmap @param mask byte array with mask bitmap @param w Width of bitmap in pixels @param h Height of bitmap in pixels */ /**************************************************************************/ void Adafruit_GFX::drawGrayscaleBitmap(int16_t x, int16_t y, uint8_t *bitmap, uint8_t *mask, int16_t w, int16_t h) { int16_t bw = (w + 7) / 8; // Bitmask scanline pad = whole byte uint8_t byte = 0; startWrite(); for(int16_t j=0; j<h; j++, y++) { for(int16_t i=0; i<w; i++ ) { if(i & 7) byte <<= 1; else byte = mask[j * bw + i / 8]; if(byte & 0x80) { writePixel(x+i, y, bitmap[j * w + i]); } } } endWrite(); } /**************************************************************************/ /*! @brief Draw a PROGMEM-resident 16-bit image (RGB 5/6/5) at the specified (x,y) position. For 16-bit display devices; no color reduction performed. @param x Top left corner x coordinate @param y Top left corner y coordinate @param bitmap byte array with 16-bit color bitmap @param w Width of bitmap in pixels @param h Height of bitmap in pixels */ /**************************************************************************/ void Adafruit_GFX::drawRGBBitmap(int16_t x, int16_t y, const uint16_t bitmap[], int16_t w, int16_t h) { startWrite(); for(int16_t j=0; j<h; j++, y++) { for(int16_t i=0; i<w; i++ ) { writePixel(x+i, y, pgm_read_word(&bitmap[j * w + i])); } } endWrite(); } /**************************************************************************/ /*! @brief Draw a RAM-resident 16-bit image (RGB 5/6/5) at the specified (x,y) position. For 16-bit display devices; no color reduction performed. @param x Top left corner x coordinate @param y Top left corner y coordinate @param bitmap byte array with 16-bit color bitmap @param w Width of bitmap in pixels @param h Height of bitmap in pixels */ /**************************************************************************/ void Adafruit_GFX::drawRGBBitmap(int16_t x, int16_t y, uint16_t *bitmap, int16_t w, int16_t h) { startWrite(); for(int16_t j=0; j<h; j++, y++) { for(int16_t i=0; i<w; i++ ) { writePixel(x+i, y, bitmap[j * w + i]); } } endWrite(); } /**************************************************************************/ /*! @brief Draw a PROGMEM-resident 16-bit image (RGB 5/6/5) with a 1-bit mask (set bits = opaque, unset bits = clear) at the specified (x,y) position. BOTH buffers (color and mask) must be PROGMEM-resident. For 16-bit display devices; no color reduction performed. @param x Top left corner x coordinate @param y Top left corner y coordinate @param bitmap byte array with 16-bit color bitmap @param mask byte array with monochrome mask bitmap @param w Width of bitmap in pixels @param h Height of bitmap in pixels */ /**************************************************************************/ void Adafruit_GFX::drawRGBBitmap(int16_t x, int16_t y, const uint16_t bitmap[], const uint8_t mask[], int16_t w, int16_t h) { int16_t bw = (w + 7) / 8; // Bitmask scanline pad = whole byte uint8_t byte = 0; startWrite(); for(int16_t j=0; j<h; j++, y++) { for(int16_t i=0; i<w; i++ ) { if(i & 7) byte <<= 1; else byte = pgm_read_byte(&mask[j * bw + i / 8]); if(byte & 0x80) { writePixel(x+i, y, pgm_read_word(&bitmap[j * w + i])); } } } endWrite(); } /**************************************************************************/ /*! @brief Draw a RAM-resident 16-bit image (RGB 5/6/5) with a 1-bit mask (set bits = opaque, unset bits = clear) at the specified (x,y) position. BOTH buffers (color and mask) must be RAM-resident. For 16-bit display devices; no color reduction performed. @param x Top left corner x coordinate @param y Top left corner y coordinate @param bitmap byte array with 16-bit color bitmap @param mask byte array with monochrome mask bitmap @param w Width of bitmap in pixels @param h Height of bitmap in pixels */ /**************************************************************************/ void Adafruit_GFX::drawRGBBitmap(int16_t x, int16_t y, uint16_t *bitmap, uint8_t *mask, int16_t w, int16_t h) { int16_t bw = (w + 7) / 8; // Bitmask scanline pad = whole byte uint8_t byte = 0; startWrite(); for(int16_t j=0; j<h; j++, y++) { for(int16_t i=0; i<w; i++ ) { if(i & 7) byte <<= 1; else byte = mask[j * bw + i / 8]; if(byte & 0x80) { writePixel(x+i, y, bitmap[j * w + i]); } } } endWrite(); } // TEXT- AND CHARACTER-HANDLING FUNCTIONS ---------------------------------- // Draw a character /**************************************************************************/ /*! @brief Draw a single character @param x Bottom left corner x coordinate @param y Bottom left corner y coordinate @param c The 8-bit font-indexed character (likely ascii) @param color 16-bit 5-6-5 Color to draw chraracter with @param bg 16-bit 5-6-5 Color to fill background with (if same as color, no background) @param size Font magnification level, 1 is 'original' size */ /**************************************************************************/ void Adafruit_GFX::drawChar(int16_t x, int16_t y, unsigned char c, uint16_t color, uint16_t bg, uint8_t size) { if(!gfxFont) { // 'Classic' built-in font if((x >= _width) || // Clip right (y >= _height) || // Clip bottom ((x + 6 * size - 1) < 0) || // Clip left ((y + 8 * size - 1) < 0)) // Clip top return; if(!_cp437 && (c >= 176)) c++; // Handle 'classic' charset behavior startWrite(); for(int8_t i=0; i<5; i++ ) { // Char bitmap = 5 columns uint8_t line = pgm_read_byte(&font[c * 5 + i]); for(int8_t j=0; j<8; j++, line >>= 1) { if(line & 1) { if(size == 1) writePixel(x+i, y+j, color); else writeFillRect(x+i*size, y+j*size, size, size, color); } else if(bg != color) { if(size == 1) writePixel(x+i, y+j, bg); else writeFillRect(x+i*size, y+j*size, size, size, bg); } } } if(bg != color) { // If opaque, draw vertical line for last column if(size == 1) writeFastVLine(x+5, y, 8, bg); else writeFillRect(x+5*size, y, size, 8*size, bg); } endWrite(); } else { // Custom font // Character is assumed previously filtered by write() to eliminate // newlines, returns, non-printable characters, etc. Calling // drawChar() directly with 'bad' characters of font may cause mayhem! c -= (uint8_t)pgm_read_byte(&gfxFont->first); uint8_t ya = pgm_read_byte(&gfxFont->yAdvance); GFXglyph *glyph = &(((GFXglyph *)pgm_read_pointer(&gfxFont->glyph))[c]); uint8_t *bitmap = (uint8_t *)pgm_read_pointer(&gfxFont->bitmap); uint16_t zz,bo = pgm_read_word(&glyph->bitmapOffset); uint8_t w = pgm_read_byte(&glyph->width), h = pgm_read_byte(&glyph->height), xa = pgm_read_byte(&glyph->xAdvance); int8_t xo = pgm_read_byte(&glyph->xOffset), yo = pgm_read_byte(&glyph->yOffset); uint8_t xx, yy, bits = 0, bit = 0; int16_t xo16 = 0, yo16 = 0; if(size > 1) { xo16 = xo; yo16 = yo; } // Todo: Add character clipping here // NOTE: THERE IS NO 'BACKGROUND' COLOR OPTION ON CUSTOM FONTS. // THIS IS ON PURPOSE AND BY DESIGN. The background color feature // has typically been used with the 'classic' font to overwrite old // screen contents with new data. This ONLY works because the // characters are a uniform size; it's not a sensible thing to do with // proportionally-spaced fonts with glyphs of varying sizes (and that // may overlap). To replace previously-drawn text when using a custom // font, use the getTextBounds() function to determine the smallest // rectangle encompassing a string, erase the area with fillRect(), // then draw new text. This WILL infortunately 'blink' the text, but // is unavoidable. Drawing 'background' pixels will NOT fix this, // only creates a new set of problems. Have an idea to work around // this (a canvas object type for MCUs that can afford the RAM and // displays supporting setAddrWindow() and pushColors()), but haven't // implemented this yet. startWrite(); for(yy=0; yy<ya; yy++) { for(xx=0; xx<xa; xx++) { zz = bg; if ((yy>=(30+yo))&&(yy<(30+yo+h))&&(xx>=xo)&&(xx<(xo+w))) { if(!(bit++ & 7)) { bits = pgm_read_byte(&bitmap[bo++]); } if(bits & 0x80) { zz = color; } bits <<= 1; } writePixel(x+xx, y-30+yy, zz); } } endWrite(); } // End classic vs custom font } /**************************************************************************/ /*! @brief Print one byte/character of data, used to support print() @param c The 8-bit ascii character to write */ /**************************************************************************/ size_t Adafruit_GFX::write(uint8_t c) { if(!gfxFont) { // 'Classic' built-in font if(c == '\n') { // Newline? cursor_x = 0; // Reset x to zero, cursor_y += textsize * 8; // advance y one line } else if(c != '\r') { // Ignore carriage returns if(wrap && ((cursor_x + textsize * 6) > _width)) { // Off right? cursor_x = 0; // Reset x to zero, cursor_y += textsize * 8; // advance y one line } drawChar(cursor_x, cursor_y, c, textcolor, textbgcolor, textsize); cursor_x += textsize * 6; // Advance x one char } } else { // Custom font if(c == '\n') { cursor_x = 0; cursor_y += (int16_t)textsize * (uint8_t)pgm_read_byte(&gfxFont->yAdvance); } else if(c != '\r') { uint8_t first = pgm_read_byte(&gfxFont->first); if((c >= first) && (c <= (uint8_t)pgm_read_byte(&gfxFont->last))) { GFXglyph *glyph = &(((GFXglyph *)pgm_read_pointer( &gfxFont->glyph))[c - first]); uint8_t w = pgm_read_byte(&glyph->width), h = pgm_read_byte(&glyph->height); if((w > 0) && (h > 0)) { // Is there an associated bitmap? int16_t xo = (int8_t)pgm_read_byte(&glyph->xOffset); // sic if(wrap && ((cursor_x + textsize * (xo + w)) > _width)) { cursor_x = 0; cursor_y += (int16_t)textsize * (uint8_t)pgm_read_byte(&gfxFont->yAdvance); } drawChar(cursor_x, cursor_y, c, textcolor, textbgcolor, textsize); } cursor_x += (uint8_t)pgm_read_byte(&glyph->xAdvance) * (int16_t)textsize; } } } return 1; } /**************************************************************************/ /*! @brief Set text 'magnification' size. Each increase in s makes 1 pixel that much bigger. @param s Desired text size. 1 is default 6x8, 2 is 12x16, 3 is 18x24, etc */ /**************************************************************************/ void Adafruit_GFX::setTextSize(uint8_t s) { textsize = (s > 0) ? s : 1; } /**************************************************************************/ /*! @brief Set rotation setting for display @param x 0 thru 3 corresponding to 4 cardinal rotations */ /**************************************************************************/ 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; } } /**************************************************************************/ /*! @brief Set the font to display when print()ing, either custom or default @param f The GFXfont object, if NULL use built in 6x8 font */ /**************************************************************************/ void Adafruit_GFX::setFont(const GFXfont *f) { if(f) { // Font struct pointer passed in? if(!gfxFont) { // And no current font struct? // Switching from classic to new font behavior. // Move cursor pos down 6 pixels so it's on baseline. cursor_y += 6; } } else if(gfxFont) { // NULL passed. Current font struct defined? // Switching from new to classic font behavior. // Move cursor pos up 6 pixels so it's at top-left of char. cursor_y -= 6; } gfxFont = (GFXfont *)f; } /**************************************************************************/ /*! @brief Helper to determine size of a character with current font/size. Broke this out as it's used by both the PROGMEM- and RAM-resident getTextBounds() functions. @param c The ascii character in question @param x Pointer to x location of character @param y Pointer to y location of character @param minx Minimum clipping value for X @param miny Minimum clipping value for Y @param maxx Maximum clipping value for X @param maxy Maximum clipping value for Y */ /**************************************************************************/ void Adafruit_GFX::charBounds(char c, int16_t *x, int16_t *y, int16_t *minx, int16_t *miny, int16_t *maxx, int16_t *maxy) { if(gfxFont) { if(c == '\n') { // Newline? *x = 0; // Reset x to zero, advance y by one line *y += textsize * (uint8_t)pgm_read_byte(&gfxFont->yAdvance); } else if(c != '\r') { // Not a carriage return; is normal char uint8_t first = pgm_read_byte(&gfxFont->first), last = pgm_read_byte(&gfxFont->last); if((c >= first) && (c <= last)) { // Char present in this font? GFXglyph *glyph = &(((GFXglyph *)pgm_read_pointer( &gfxFont->glyph))[c - first]); uint8_t gw = pgm_read_byte(&glyph->width), gh = pgm_read_byte(&glyph->height), xa = pgm_read_byte(&glyph->xAdvance); int8_t xo = pgm_read_byte(&glyph->xOffset), yo = pgm_read_byte(&glyph->yOffset); if(wrap && ((*x+(((int16_t)xo+gw)*textsize)) > _width)) { *x = 0; // Reset x to zero, advance y by one line *y += textsize * (uint8_t)pgm_read_byte(&gfxFont->yAdvance); } int16_t ts = (int16_t)textsize, x1 = *x + xo * ts, y1 = *y + yo * ts, x2 = x1 + gw * ts - 1, y2 = y1 + gh * ts - 1; if(x1 < *minx) *minx = x1; if(y1 < *miny) *miny = y1; if(x2 > *maxx) *maxx = x2; if(y2 > *maxy) *maxy = y2; *x += xa * ts; } } } else { // Default font if(c == '\n') { // Newline? *x = 0; // Reset x to zero, *y += textsize * 8; // advance y one line // min/max x/y unchaged -- that waits for next 'normal' character } else if(c != '\r') { // Normal char; ignore carriage returns if(wrap && ((*x + textsize * 6) > _width)) { // Off right? *x = 0; // Reset x to zero, *y += textsize * 8; // advance y one line } int x2 = *x + textsize * 6 - 1, // Lower-right pixel of char y2 = *y + textsize * 8 - 1; if(x2 > *maxx) *maxx = x2; // Track max x, y if(y2 > *maxy) *maxy = y2; if(*x < *minx) *minx = *x; // Track min x, y if(*y < *miny) *miny = *y; *x += textsize * 6; // Advance x one char } } } /**************************************************************************/ /*! @brief Helper to determine size of a string with current font/size. Pass string and a cursor position, returns UL corner and W,H. @param str The ascii string to measure @param x The current cursor X @param y The current cursor Y @param x1 The boundary X coordinate, set by function @param y1 The boundary Y coordinate, set by function @param w The boundary width, set by function @param h The boundary height, set by function */ /**************************************************************************/ void Adafruit_GFX::getTextBounds(const char *str, int16_t x, int16_t y, int16_t *x1, int16_t *y1, uint16_t *w, uint16_t *h) { uint8_t c; // Current character *x1 = x; *y1 = y; *w = *h = 0; int16_t minx = _width, miny = _height, maxx = -1, maxy = -1; while((c = *str++)) charBounds(c, &x, &y, &minx, &miny, &maxx, &maxy); if(maxx >= minx) { *x1 = minx; *w = maxx - minx + 1; } if(maxy >= miny) { *y1 = miny; *h = maxy - miny + 1; } } /**************************************************************************/ /*! @brief Helper to determine size of a string with current font/size. Pass string and a cursor position, returns UL corner and W,H. @param str The ascii string to measure (as an arduino String() class) @param x The current cursor X @param y The current cursor Y @param x1 The boundary X coordinate, set by function @param y1 The boundary Y coordinate, set by function @param w The boundary width, set by function @param h The boundary height, set by function */ /**************************************************************************/ void Adafruit_GFX::getTextBounds(const String &str, int16_t x, int16_t y, int16_t *x1, int16_t *y1, uint16_t *w, uint16_t *h) { if (str.length() != 0) { getTextBounds(const_cast<char*>(str.c_str()), x, y, x1, y1, w, h); } } /**************************************************************************/ /*! @brief Helper to determine size of a PROGMEM string with current font/size. Pass string and a cursor position, returns UL corner and W,H. @param str The flash-memory ascii string to measure @param x The current cursor X @param y The current cursor Y @param x1 The boundary X coordinate, set by function @param y1 The boundary Y coordinate, set by function @param w The boundary width, set by function @param h The boundary height, set by function */ /**************************************************************************/ void Adafruit_GFX::getTextBounds(const __FlashStringHelper *str, int16_t x, int16_t y, int16_t *x1, int16_t *y1, uint16_t *w, uint16_t *h) { uint8_t *s = (uint8_t *)str, c; *x1 = x; *y1 = y; *w = *h = 0; int16_t minx = _width, miny = _height, maxx = -1, maxy = -1; while((c = pgm_read_byte(s++))) charBounds(c, &x, &y, &minx, &miny, &maxx, &maxy); if(maxx >= minx) { *x1 = minx; *w = maxx - minx + 1; } if(maxy >= miny) { *y1 = miny; *h = maxy - miny + 1; } } /**************************************************************************/ /*! @brief Invert the display (ideally using built-in hardware command) @param i True if you want to invert, false to make 'normal' */ /**************************************************************************/ void Adafruit_GFX::invertDisplay(boolean i) { // Do nothing, must be subclassed if supported by hardware } /***************************************************************************/ /**************************************************************************/ /*! @brief Create a simple drawn button UI element */ /**************************************************************************/ Adafruit_GFX_Button::Adafruit_GFX_Button(void) { _gfx = 0; } /**************************************************************************/ /*! @brief Initialize button with our desired color/size/settings @param gfx Pointer to our display so we can draw to it! @param x The X coordinate of the center of the button @param y The Y coordinate of the center of the button @param w Width of the buttton @param h Height of the buttton @param outline Color of the outline (16-bit 5-6-5 standard) @param fill Color of the button fill (16-bit 5-6-5 standard) @param textcolor Color of the button label (16-bit 5-6-5 standard) @param label Ascii string of the text inside the button @param textsize The font magnification of the label text */ /**************************************************************************/ // Classic initButton() function: pass center & size void Adafruit_GFX_Button::initButton( Adafruit_GFX *gfx, int16_t x, int16_t y, uint16_t w, uint16_t h, uint16_t outline, uint16_t fill, uint16_t textcolor, char *label, uint8_t textsize) { // Tweak arguments and pass to the newer initButtonUL() function... initButtonUL(gfx, x - (w / 2), y - (h / 2), w, h, outline, fill, textcolor, label, textsize); } /**************************************************************************/ /*! @brief Initialize button with our desired color/size/settings, with upper-left coordinates @param gfx Pointer to our display so we can draw to it! @param x1 The X coordinate of the Upper-Left corner of the button @param y1 The Y coordinate of the Upper-Left corner of the button @param w Width of the buttton @param h Height of the buttton @param outline Color of the outline (16-bit 5-6-5 standard) @param fill Color of the button fill (16-bit 5-6-5 standard) @param textcolor Color of the button label (16-bit 5-6-5 standard) @param label Ascii string of the text inside the button @param textsize The font magnification of the label text */ /**************************************************************************/ void Adafruit_GFX_Button::initButtonUL( Adafruit_GFX *gfx, int16_t x1, int16_t y1, uint16_t w, uint16_t h, uint16_t outline, uint16_t fill, uint16_t textcolor, char *label, uint8_t textsize) { _x1 = x1; _y1 = y1; _w = w; _h = h; _outlinecolor = outline; _fillcolor = fill; _textcolor = textcolor; _textsize = textsize; _gfx = gfx; strncpy(_label, label, 9); } /**************************************************************************/ /*! @brief Draw the button on the screen @param inverted Whether to draw with fill/text swapped to indicate 'pressed' */ /**************************************************************************/ void Adafruit_GFX_Button::drawButton(boolean inverted) { uint16_t fill, outline, text; if(!inverted) { fill = _fillcolor; outline = _outlinecolor; text = _textcolor; } else { fill = _textcolor; outline = _outlinecolor; text = _fillcolor; } uint8_t r = min(_w, _h) / 4; // Corner radius _gfx->fillRoundRect(_x1, _y1, _w, _h, r, fill); _gfx->drawRoundRect(_x1, _y1, _w, _h, r, outline); _gfx->setCursor(_x1 + (_w/2) - (strlen(_label) * 3 * _textsize), _y1 + (_h/2) - (4 * _textsize)); _gfx->setTextColor(text); _gfx->setTextSize(_textsize); _gfx->print(_label); } /**************************************************************************/ /*! @brief Helper to let us know if a coordinate is within the bounds of the button @param x The X coordinate to check @param y The Y coordinate to check @returns True if within button graphics outline */ /**************************************************************************/ boolean Adafruit_GFX_Button::contains(int16_t x, int16_t y) { return ((x >= _x1) && (x < (int16_t) (_x1 + _w)) && (y >= _y1) && (y < (int16_t) (_y1 + _h))); } /**************************************************************************/ /*! @brief Query whether the button was pressed since we last checked state @returns True if was not-pressed before, now is. */ /**************************************************************************/ boolean Adafruit_GFX_Button::justPressed() { return (currstate && !laststate); } /**************************************************************************/ /*! @brief Query whether the button was released since we last checked state @returns True if was pressed before, now is not. */ /**************************************************************************/ boolean Adafruit_GFX_Button::justReleased() { return (!currstate && laststate); } // ------------------------------------------------------------------------- // GFXcanvas1, GFXcanvas8 and GFXcanvas16 (currently a WIP, don't get too // comfy with the implementation) provide 1-, 8- and 16-bit offscreen // canvases, the address of which can be passed to drawBitmap() or // pushColors() (the latter appears only in a couple of GFX-subclassed TFT // libraries at this time). This is here mostly to help with the recently- // added proportionally-spaced fonts; adds a way to refresh a section of the // screen without a massive flickering clear-and-redraw...but maybe you'll // find other uses too. VERY RAM-intensive, since the buffer is in MCU // memory and not the display driver...GXFcanvas1 might be minimally useful // on an Uno-class board, but this and the others are much more likely to // require at least a Mega or various recent ARM-type boards (recommended, // as the text+bitmap draw can be pokey). GFXcanvas1 requires 1 bit per // pixel (rounded up to nearest byte per scanline), GFXcanvas8 is 1 byte // per pixel (no scanline pad), and GFXcanvas16 uses 2 bytes per pixel (no // scanline pad). // NOT EXTENSIVELY TESTED YET. MAY CONTAIN WORST BUGS KNOWN TO HUMANKIND. /**************************************************************************/ /*! @brief Instatiate a GFX 1-bit canvas context for graphics @param w Display width, in pixels @param h Display height, in pixels */ /**************************************************************************/ GFXcanvas1::GFXcanvas1(uint16_t w, uint16_t h) : Adafruit_GFX(w, h) { uint16_t bytes = ((w + 7) / 8) * h; if((buffer = (uint8_t *)malloc(bytes))) { memset(buffer, 0, bytes); } } /**************************************************************************/ /*! @brief Delete the canvas, free memory */ /**************************************************************************/ GFXcanvas1::~GFXcanvas1(void) { if(buffer) free(buffer); } /**************************************************************************/ /*! @brief Draw a pixel to the canvas framebuffer @param x x coordinate @param y y coordinate @param color 16-bit 5-6-5 Color to fill with */ /**************************************************************************/ void GFXcanvas1::drawPixel(int16_t x, int16_t y, uint16_t color) { #ifdef __AVR__ // Bitmask tables of 0x80>>X and ~(0x80>>X), because X>>Y is slow on AVR static const uint8_t PROGMEM GFXsetBit[] = { 0x80, 0x40, 0x20, 0x10, 0x08, 0x04, 0x02, 0x01 }, GFXclrBit[] = { 0x7F, 0xBF, 0xDF, 0xEF, 0xF7, 0xFB, 0xFD, 0xFE }; #endif if(buffer) { if((x < 0) || (y < 0) || (x >= _width) || (y >= _height)) return; int16_t t; switch(rotation) { case 1: t = x; x = WIDTH - 1 - y; y = t; break; case 2: x = WIDTH - 1 - x; y = HEIGHT - 1 - y; break; case 3: t = x; x = y; y = HEIGHT - 1 - t; break; } uint8_t *ptr = &buffer[(x / 8) + y * ((WIDTH + 7) / 8)]; #ifdef __AVR__ if(color) *ptr |= pgm_read_byte(&GFXsetBit[x & 7]); else *ptr &= pgm_read_byte(&GFXclrBit[x & 7]); #else if(color) *ptr |= 0x80 >> (x & 7); else *ptr &= ~(0x80 >> (x & 7)); #endif } } /**************************************************************************/ /*! @brief Fill the framebuffer completely with one color @param color 16-bit 5-6-5 Color to fill with */ /**************************************************************************/ void GFXcanvas1::fillScreen(uint16_t color) { if(buffer) { uint16_t bytes = ((WIDTH + 7) / 8) * HEIGHT; memset(buffer, color ? 0xFF : 0x00, bytes); } } /**************************************************************************/ /*! @brief Instatiate a GFX 8-bit canvas context for graphics @param w Display width, in pixels @param h Display height, in pixels */ /**************************************************************************/ GFXcanvas8::GFXcanvas8(uint16_t w, uint16_t h) : Adafruit_GFX(w, h) { uint32_t bytes = w * h; if((buffer = (uint8_t *)malloc(bytes))) { memset(buffer, 0, bytes); } } /**************************************************************************/ /*! @brief Delete the canvas, free memory */ /**************************************************************************/ GFXcanvas8::~GFXcanvas8(void) { if(buffer) free(buffer); } /**************************************************************************/ /*! @brief Draw a pixel to the canvas framebuffer @param x x coordinate @param y y coordinate @param color 16-bit 5-6-5 Color to fill with */ /**************************************************************************/ void GFXcanvas8::drawPixel(int16_t x, int16_t y, uint16_t color) { if(buffer) { if((x < 0) || (y < 0) || (x >= _width) || (y >= _height)) return; int16_t t; switch(rotation) { case 1: t = x; x = WIDTH - 1 - y; y = t; break; case 2: x = WIDTH - 1 - x; y = HEIGHT - 1 - y; break; case 3: t = x; x = y; y = HEIGHT - 1 - t; break; } buffer[x + y * WIDTH] = color; } } /**************************************************************************/ /*! @brief Fill the framebuffer completely with one color @param color 16-bit 5-6-5 Color to fill with */ /**************************************************************************/ void GFXcanvas8::fillScreen(uint16_t color) { if(buffer) { memset(buffer, color, WIDTH * HEIGHT); } } void GFXcanvas8::writeFastHLine(int16_t x, int16_t y, int16_t w, uint16_t color) { if((x >= _width) || (y < 0) || (y >= _height)) return; int16_t x2 = x + w - 1; if(x2 < 0) return; // Clip left/right if(x < 0) { x = 0; w = x2 + 1; } if(x2 >= _width) w = _width - x; int16_t t; switch(rotation) { case 1: t = x; x = WIDTH - 1 - y; y = t; break; case 2: x = WIDTH - 1 - x; y = HEIGHT - 1 - y; break; case 3: t = x; x = y; y = HEIGHT - 1 - t; break; } memset(buffer + y * WIDTH + x, color, w); } /**************************************************************************/ /*! @brief Instatiate a GFX 16-bit canvas context for graphics @param w Display width, in pixels @param h Display height, in pixels */ /**************************************************************************/ GFXcanvas16::GFXcanvas16(uint16_t w, uint16_t h) : Adafruit_GFX(w, h) { uint32_t bytes = w * h * 2; if((buffer = (uint16_t *)malloc(bytes))) { memset(buffer, 0, bytes); } } /**************************************************************************/ /*! @brief Delete the canvas, free memory */ /**************************************************************************/ GFXcanvas16::~GFXcanvas16(void) { if(buffer) free(buffer); } /**************************************************************************/ /*! @brief Draw a pixel to the canvas framebuffer @param x x coordinate @param y y coordinate @param color 16-bit 5-6-5 Color to fill with */ /**************************************************************************/ void GFXcanvas16::drawPixel(int16_t x, int16_t y, uint16_t color) { if(buffer) { if((x < 0) || (y < 0) || (x >= _width) || (y >= _height)) return; int16_t t; switch(rotation) { case 1: t = x; x = WIDTH - 1 - y; y = t; break; case 2: x = WIDTH - 1 - x; y = HEIGHT - 1 - y; break; case 3: t = x; x = y; y = HEIGHT - 1 - t; break; } buffer[x + y * WIDTH] = color; } } /**************************************************************************/ /*! @brief Fill the framebuffer completely with one color @param color 16-bit 5-6-5 Color to fill with */ /**************************************************************************/ void GFXcanvas16::fillScreen(uint16_t color) { if(buffer) { uint8_t hi = color >> 8, lo = color & 0xFF; if(hi == lo) { memset(buffer, lo, WIDTH * HEIGHT * 2); } else { uint32_t i, pixels = WIDTH * HEIGHT; for(i=0; i<pixels; i++) buffer[i] = color; } } } /**************************************************************************/ /*! @brief Reverses the "endian-ness" of each 16-bit pixel within the canvas; little-endian to big-endian, or big-endian to little. Most microcontrollers (such as SAMD) are little-endian, while most displays tend toward big-endianness. All the drawing functions (including RGB bitmap drawing) take care of this automatically, but some specialized code (usually involving DMA) can benefit from having pixel data already in the display-native order. Note that this does NOT convert to a SPECIFIC endian-ness, it just flips the bytes within each word. */ /**************************************************************************/ void GFXcanvas16::byteSwap(void) { if(buffer) { uint32_t i, pixels = WIDTH * HEIGHT; for(i=0; i<pixels; i++) buffer[i] = __builtin_bswap16(buffer[i]); } }надо проверить идею с выводом пробела - закоменти строки 1166 и 1174 в той библиотеке что я правил,
а в printnum убери '0' совсем и погляди что будет
в предедущем посте файл библиотеки. строки 1166 и 1174 чет не в тему
1166//if((w > 0) && (h > 0)) {// Is there an associated bitmap?1167int16_t xo = (int8_t)pgm_read_byte(&glyph->xOffset);// sic1168if(wrap && ((cursor_x + textsize * (xo + w)) > _width)) {1169cursor_x = 0;1170cursor_y += (int16_t)textsize *1171(uint8_t)pgm_read_byte(&gfxFont->yAdvance);1172}1173drawChar(cursor_x, cursor_y, c, textcolor, textbgcolor, textsize);1174//}Всё четко - пробуй ! Не вёсь кусок, а именно 2 строки
блин ты убийца библиотек:). все работает и затирает. с этим покончино. проблема следующая инфа выводится примерно через 2-3 секунды. Блин я с вас двоих поражаюсь, головы у вас золотые...
На примере RPM
119 int RPM = 0; int RPM_last = 1;
485 if (RPM != RPM_last) {myGLCD.printNumI(RPM, 210, 215,5);RPM_last=RPM;}
и так надо сделать для всех параметров что выводятся на экран
int RPM = 0;
int RPM_last = 1;
.........................................................
myGLCD.printNumI(RPM, 210, 215,5);
485 if (RPM != RPM_last) {myGLCD.printNumI(RPM, 210, 215,5);RPM_last=RPM;}
или так по две строки?
Добавить жирное. Логика - если показатель не изменился, то и выводить его не надо. Вывод - это рисование по точкам - крайне медленная штука
блин ты убийца библиотек:). все работает и затирает. с этим покончино. проблема следующая инфа выводится примерно через 2-3 секунды. Блин я с вас двоих поражаюсь, головы у вас золотые...
Щас налетят охотники за головами )))
Щас налетят охотники за головами )))
Денег бы у охотников хватило ...
пошел пилить строки, потом скажу че да как....
для float надо соответственно создавать новую переменную float
и вот ещё:
810if(date<10 ) {811myGLCD.print("0", 85, 7);812myGLCD.printNumI(date, 100, 7); }813elseif(date >=10) {814myGLCD.printNumI(date, 85, 7); }просто меняется на
myGLCD.printNumI(date, 85, 7, 2, '0');
и так ещё три раза ниже только date менется на day hour minute ...
так время вроде Макс пропадчил, онбновляется только то что изменяется. или ты имешь ввиду весь кусок можно заменить на одну строку?
я не про обновление - я про вывод ведущего нуля
время тратится на лишний код
ИМЕННО - кусок на строку
понял. про три куска тоже понял.
и там же ещё три таких куска
при таком раскладе
if (mon!=mon_last || reNew){
myGLCD.printNumI(mon, 130, 7, 2, '0'); }
mon_last = mon;
}
дает ошибку
exit status 1
expected unqualified-id before 'if'
void Watch (){ DateTime now = rtc.now(); int minut = now.minute(); int hour = now.hour(); int mon = now.month(); int date = now.day(); int Year = now.year(); static int minut_last; static int hour_last; static int mon_last; static int date_last; static int Year_last; myGLCD.setTextColor(WHITE, BLACK); //белый цвет цифры if (date != date_last || reNew){ myGLCD.printNumI(date, 85, 7, 2, '0'); } date_last = date; } if (mon!=mon_last || reNew){ myGLCD.printNumI(mon, 130, 7, 2, '0'); } mon_last = mon; } if (Year!=Year_last || reNew) { myGLCD.printNumI(Year, 175, 7); Year_last = Year;} if (hour!=hour_last || reNew){ myGLCD.printNumI(hour, 255, 7, 2, '0'); } hour_last = hour; } if (minut!=minut_last || reNew ){ myGLCD.printNumI(date, 300, 7, 2, '0'); } minut_last = minut; } reNew = 0; }в 16, 21, 29, 34 лишние - }
4 if можно записать как в 26 строке
пошел пробовать.... капец, ноут батарея не держит свет вырубился. скетч был не сохранен, все долгие правки коту под хвост, но испытать успел. обновляется быстрее. с 3 секунд до 2 стало. есть косяки , может отображать то пару одних температур, обновишь страницу или перейдешь с другой может показать пару других температур. тоесть все температуры одновременно не отображает, еще заметил еще вчера что, на второй и третей странице инфы нету, не отображает, и еще раньше на моем скетче старом, при переходе или первом старте шла прописовка по строкам, строка, строка, строка и готова, а сейчас он прорисовывает какбы по буквам а не по целым строкам. фруктовая библиотека это сполошной кошмар, никогда больше экраны на этой библе брать не буду, только УТФТ. Все ну на фиг, на сегодня все. завтра заново подправлю все и еще раз буду видеть, на счет if понял
эти экраны твои ... надо везде добавить жирное ещё
119 int RPM = 0; int RPM_last = 1;
485 if (RPM != RPM_last || reNew) {myGLCD.printNumI(RPM, 210, 215,5);RPM_last=RPM;}
а раз не сохранилось, то сделаешь сразу уже по этой схеме !
ок завтра уже
мигать на экране перестало это полбеды решено. Нужно вывести Serial.println(millis()) в начале и в конце периодической печати параметров на экран и узнаешь сколько по времени эта печать на экран занимает. Скорее всего время печати то не сильно сократилось и осталось всё равно долгим, поэтому такие редкие запросы на ЭБУ.
Надо и вывод в сериал сделать отключаемым/подключаемым при компиляции. Весь вывод на экран идёт по одной точке за раз, хоть с морганием хоть без. Стирание при моргании то же идёт по одной точке за раз, так как стирается не весь экран. Весь экран стирается блоковой командой.
там это сделано
ниче не понял если чесно. Нужно попробовать ещё использовать вместо UTFTGLUE библиотеку , которая идёт с mcu_friend типа MCUFRIEND_kbv tft; если и с ней будет тормозить , экран на помойку.
UTFTGLUE сама почти ничего ничего не делает - типа заголовочника к MCUFRIEND_kbv
Командир отчитываюсь. Сделал все по твоей инструкции, результат 1.5 секунды обновление, что уже в два раза лучше чем было. Есть косяк, если перешел на другую страницу а потом вернулся на первкую то не все температуры есть, когда какя-то температура поменялась она появляется на экране. тоесть, не выводит на экран пока не поменяется, так все данные, не странице 2 и 3 таже фигня, не поменялась не видно, поменялась появляется. вот скетч
#include <Adafruit_GFX.h> #include <MCUFRIEND_kbv.h> #include <UTFTGLUE.h>//use GLUE class and constructor #include "TouchScreen.h" #include <stdint.h> #include <SPI.h> #include <EEPROM.h> //MCUFRIEND_kbv tft; #include "Fonts/Chosence_Bold16pt7b.h"; #define MINPRESSURE 200 #define MAXPRESSURE 1000 //pin 20 SCL , 21 SDA датчик реального времени #include <Wire.h> #include "RTClib.h" RTC_DS3231 rtc; UTFTGLUE myGLCD(0x1581,A2,A1,A3,A4,A0); //all dummy args const int XP = 6, XM = A2, YP = A1, YM = 7; const int TS_LEFT = 136, TS_RT = 907, TS_TOP = 139, TS_BOT = 942; TouchScreen ts = TouchScreen(XP, YP, XM, YM, 300); uint16_t ID; int x, y; char currentPage; float h; int h_last = 1; float t; int t_last = 1; bool Dvoet = 0; bool reNew = 0; #define BLACK 0x0000 #define WHITE 0xFFFF #define RED 0xF800 #define GREEN 0x07E0 #include <SoftwareSerial.h> #define TX_PCM 13 SoftwareSerial K_LINE_PCM (12, TX_PCM); //RХ,TХ #define PCM_address 0x11 // адрес PCM #define DIAG_address 0xF1 // адрес диагностики #define debugPCM // раскоментировать эту строку для отладки в Serial порту обмена с PCM //#define debugGAUGE // раскоментировать эту строку для отладки в Serial порту обмена co щитком приборов uint32_t curmillis = 0; // снимок текущего времени uint32_t prevRequest = 0; // таймер периодических запосов на PCM uint16_t RequestPeriod = 3500; // периодичность запросов на PCM uint32_t prevRESETheader=0; // таймер сброса сообщения, если данные оборвались посередине сообщения bool RESETheader_timer; // таймер сброса сообщения, если данные оборвались посередине сообщения uint32_t prev_NOanswer=0; // таймер контроля неответов от ЭБУ после подачи запросов bool NOanswer_timer = 0; // таймер контроля неответов от ЭБУ после подачи запросов byte noanswers = 0; // количество подряд неответов от ЭБУ uint32_t timerdelay = 0; // таймер ожидания байт (для успевания появления данных в буфере UART) bool Delay = 0; // таймер ожидания байт (для успевания появления данных в буфере UART) byte waitbyte_RX = 1; // задержка, мс для успевания появления данных в буфере RX // (подрегулировать в зависимости от уровня жизнидеятельности на Марсе) #define TIMER_DELAY Delay = 0; timerdelay = curmillis // включение этого таймера byte delaybyte_TX = 1; // задержка между отправкой байт в запросах, мс byte header = 0; // состояние заголовка byte message_size = 0; // размер тела сообщения byte j = 3; // инкремент byte n = 3; // количество старт байт const byte bufsize = 150; // размер буфера принятого сообщения byte MessageRx_PCM [bufsize] = {0}; // буфер принятого сообщения byte crc =0; // байт контрольной суммы // возможные варианты запросов на ЭБУ: enum REQUEST { INIT, PID, DTCERASE, DTCREAD, PRESENT, }; // текстовки запросов для отладки char* textRequest[] = { "INIT", "PID_2101", "DTC_ERASE", "DTC_READ", "PRESENT", } ; // сами запросы byte PCM_Message_TX[][5] = { {1, 0x81, 0,0,0}, // запрос инициализации {2, 0x21,0x01, 0,0}, // запрос пид 2101 {3, 0x14,0xFF,0x00, 0}, // запрос на стирание ошибок {4, 0x18,0x00,0xFF,0x00 }, // запрос на чтение ошибок {1, 0x3E, 0,0,0}, // запрос присутствия }; byte request = INIT; // переменная, показывающая какой запрос будем делать //-------------------------------------------переменные бортовика float L100M = 0; int L100M_last = 1; //расход на 100 км измеренный за поездку float L100 = 0; int L100_last = 1; //мгновенный расход литров на 100км float LHor = 0; int LHor_last = 1; //мгновенный расход топлива литров в час float L100SR = 0; //расход литров на 100км измеренный раз в интервал kmL float L100SR_TFT = 0; int L100SR_TFT_last = 1; // самый средний из расходов на 100км, он выводится на экран int L100_Eeprom[11]= {10,10,10,10,10,10,10,10,10,10,10}; int FuelZamer[10]= {0}; // массив для измерения уровня (количества) топлива int ZamerNumber = 0; // номер замера уровня (количества) топлива int n_eeprom = 0; // текущий адрес ячейки еепром для записи расхода int MAF = 0; int MAF_last = 1; //26,27 байты Sensor de flujo de aire en masa float BoostPres = 0; int BoostPres_last = 1; //28,29 байты Presión de refuerzo int RPM = 0; int RPM_last = 1; //32,33 байты Velocidad del motor int EGRmg = 0; int EGRmg_last = 1; //34,35 байты Comando EGR (Comando de recirculación de gases de escape) float BoostPresCom = 0; int BoostPresCom_last = 1; //38,39 байты Comando de presión de refuerzo int Speed = 0; int Speed_last = 1; //44,45 байты Velocidad del vehículo float DesaInjQua = 0; int DesaInjQua_last = 1; //50,51 байты Cantidad de inyección deseada float InjQua = 0; int InjQua_last = 1; //52,53 байты Cantidad de la inyección float StaDaliv = 0; int StaDaliv_last = 1; //54,55 байты Inicio de la entrega int PumpRPM = 0; int PumpRPM_last = 1; //56,57 байты Velocidad de la bomba float EGRPul = 0; int EGRPul_last = 1; //62,63 байты Relación de impulsos EGR (recirculación de gases de escape float SolenPul = 0; int SolenPul_last = 1; //64,65 байты Velocidad de solenoide de control de nivel de remolino Relación de impulsos float SolenPre = 0; int SolenPre_last = 1; //70,71 байты Relación de impulsos Presión Electroválvula de presión float DesInj = 0; int DesInj_last = 1; //72,73 байты Inyección deseada Inicio float ActInj = 0; int ActInj_last = 1; //16,17 байты Inicio de la inyección real int TempAir = 0; int TempAir_last = 1; //74,75 байты Temperatura del aire de admisión int Temp = 0; int Temp_last = 1; //14,15 байты Temperatura del refrigerante int TempOil = 0; int TempOil_last = 1; //18,19 байты Temperatura del aceite del motor int TempFuel = 0; int TempFuel_last = 1; //58,59 байты Temperatura del combustible //все что касается топлива float Fuel = 0; //остаток топлива float Fuel2 = 0; int Fuel2_last = 1; //остаток мгновенного топлива байт 16 , датчика в баке int FuelIGN = 0; // количество топлвива в баке на момент включения зажигания int Fuel_last = 0; // для формул bool flagFuelIGN = 0; // флаг записан ли остаток топлива в момент вкл. зажигания float FuelTrip = 0; int FuelTrip_last = 1; // количество литров топлива, израсходованное за один цикл включения зажигания //все что касается километража float kmAge = 0; //пробег, полученный со щитка приборов int kmAgeIGN = 0; //пробег который был в момент включения зажигания int kmAge_last = 0; // для формул bool flagkmAgeIGN = 0; //флаг записан ли пробег в момент вкл. зажигания float kmTrip = 0; int kmTrip_last = 1; //пробег за один цикл включения зажигания int kmL = 10; // интервал, через который будет происходить обновление среднего расхода на 100км int km = 0; // переменная для расчетов int kmeeprom = 10; // интервал, через который будет происходить подсчет среднеарифмитического расхода L100SR_TFT int kmTFT = 0; // переменная для расчетов периодического подсчета среднеарифмитического расхода топлива L100SR_TFT int kmREFUELING = 0; int kmREFUELING_last = 1; // пробег до заправки на остатке топлива unsigned long prevWatch = 0; unsigned long prevDvoet = 0; unsigned long prevData = 0; void setup() { uint16_t ID = myGLCD.readID(); if (ID == 0xD3D3) ID = 0x1581; // write-only shield myGLCD.begin(ID); myGLCD.InitLCD(3); myGLCD.clrScr(); myGLCD.setFont(&Chosence_Bold16pt7b); //myGLCD.fillScreen(WHITE); //myGLCD.setTextColor(WHITE, BLACK); //myGLCD.setBackColor(BLACK); Wire.begin(); rtc.begin(); //загрузка стартовой страницы currentPage = '0'; drawHomeScreen(); //подсчет среднеарифметического усредненного расхода for (int i = 0; i < 11; i++) L100_Eeprom [i]= EEPROM.read(i); for (int i = 0; i < 11; i++) L100SR_TFT = L100SR_TFT + L100_Eeprom [i]; L100SR_TFT = (float)L100SR_TFT/110.0; if (L100SR_TFT<0) L100SR_TFT = 0; if (L100SR_TFT>99) L100SR_TFT = 99; // строка ниже используется для настройки даты и времени часов // раскоментировать, выставить времая и дату, залить в ардуино. в скетче закоментировать // обратно и залить еще раз, иначе каждый раз будет по новой выствлятся это же время и дата // (год, месяц, день, часы, минуты, секунды) //rtc.adjust(DateTime(2017, 7, 21, 13, 57, 0)); #if defined debugPCM or debugGAUGE Serial.begin(115200); #endif K_LINE_PCM.begin(10400); pinMode(TX_PCM, OUTPUT); } void loop() { curmillis = millis(); // снимок текущего времени if (curmillis - prevRequest > RequestPeriod && header == 0 ) { if (request == INIT) fastinit(); // при необходимости делаем переподключение к PCM else {sendMessagePCM(request); // отправляем на PCM текущий запрос if (request == PID) RequestPeriod = 600; if (request == DTCERASE || request == DTCREAD) RequestPeriod = 2500;} prevRequest = curmillis; } receivePCM (); // приём сообщений от PCM if (header == 0) Menu (); if (curmillis - prevWatch > 3000) { Watch (); prevWatch = curmillis;} //if (curmillis - prevDvoet > 500) { if (!Dvoet) {myGLCD.setTextColor(WHITE); } else {myGLCD.setTextColor(BLACK); } myGLCD.print(":", 290, 5); prevDvoet = curmillis; Dvoet=!Dvoet;} }// end loop void fastinit() { digitalWrite (TX_PCM, HIGH); // bus idle delay(1500); digitalWrite (TX_PCM, LOW); // first part fastinit (25 ms LOW) delay(25); digitalWrite (TX_PCM, HIGH); // second part fastinit (25 ms HIGH) delay(25); K_LINE_PCM.begin(10400); sendMessagePCM(INIT); // send start communication message } void receivePCM () { if (K_LINE_PCM.available() ){ // первый старт байт if (header == 0 && Delay){TIMER_DELAY ; MessageRx_PCM[0]=K_LINE_PCM.read(); if (MessageRx_PCM[0]!=0xFF && bitRead (MessageRx_PCM[0],7)){header = 1; RESETheader_timer = 1; prevRESETheader = curmillis; #ifdef debugPCM Serial.print (F("Receive PCM: ")); printDebugRX(MessageRx_PCM[0]); #endif } } // второй старт байт if (header == 1 && Delay){TIMER_DELAY ; MessageRx_PCM[1]=K_LINE_PCM.read(); #ifdef debugPCM printDebugRX (MessageRx_PCM[1]); #endif if (MessageRx_PCM[1]==DIAG_address){ header = 2;} else { #ifdef debugPCM Serial.println(F(" PCM Message fail address")); #endif header = 0; RESETheader_timer = 0;}} // третий старт байт if (header == 2 && Delay){ TIMER_DELAY ; MessageRx_PCM[2]=K_LINE_PCM.read(); #ifdef debugPCM printDebugRX (MessageRx_PCM[2]); #endif if (MessageRx_PCM[2]==PCM_address){ message_size = MessageRx_PCM[0]; prevRESETheader = curmillis; if (MessageRx_PCM[0] !=0x80) {header = 4; bitWrite (message_size, 7 , 0);j=3;n=3;} else {header = 3; j=4;n=4;} if (message_size > bufsize) message_size = bufsize; crc = 0;} else {header = 0; #ifdef debugPCM Serial.println(F("PCM Message fail address")); #endif RESETheader_timer = 0;} } // если размер сообщения указан в дополнительном байте (нулевой байт 0x80) читаем этот дополнительный байт: if (header == 3 && Delay){ TIMER_DELAY ; prevRESETheader = curmillis; MessageRx_PCM[3]=K_LINE_PCM.read(); #ifdef debugPCM printDebugRX(MessageRx_PCM[3]); #endif message_size = MessageRx_PCM[3]; if (message_size > bufsize) message_size = bufsize; crc = 0; header = 4; } // пишем тело сообщения if (header == 4 && Delay && j< message_size+n+1) { MessageRx_PCM[j] = K_LINE_PCM.read(); prevRESETheader = curmillis; if (j<message_size+n) crc+= MessageRx_PCM[j]; // подсчёт КС if (j==message_size+n) header = 5; TIMER_DELAY ; #ifdef debugPCM printDebugRX(MessageRx_PCM[j]); #endif j++; } } // сообщение приняли, действуем if (header == 5) {TIMER_DELAY ; #ifdef debugPCM Serial.println(); #endif NOanswer_timer = 0; noanswers = 0; // сбрасываем таймер контроля неответов for(byte i = 0; i<n; i++) crc+=MessageRx_PCM[i]; // прибавляем к контрольной сумме старт байты // если контрольная сумма верна: if ( crc == MessageRx_PCM[message_size+n]) { #ifdef debugPCM Serial.print (F("Received message is OK! Checksum is correct!")); Serial.print (F(" ")); Serial.println (millis()); // Если КС совпала, тут чёнибудь нужное делаем printDebugRX_CSgood(); #endif if (MessageRx_PCM[n]==0xC1 && MessageRx_PCM[n+1]==0x6B && MessageRx_PCM[n+2]==0x8F) { if (currentPage!=3) {request = PID; RequestPeriod = 70;} else request = PRESENT, RequestPeriod = 4000; prevRequest = curmillis; // receive good INIT } else if (MessageRx_PCM[n]==0x58) Troublecodes (); // DTC else if (MessageRx_PCM[n]==0x54 && MessageRx_PCM[n+1]==0xFF && MessageRx_PCM[n+2]==0x00){ request = PRESENT; RequestPeriod = 4000; prevRequest = curmillis;} // DTC are cleared else if (MessageRx_PCM[n]==0x61 && MessageRx_PCM[n+1]==0x01) {dataVars() ; RequestPeriod = 70; prevRequest = curmillis; } // receive DataStream } // если контрольная сумма не совпала: #ifdef debugPCM else Serial.println("CRC fail!!!" ); #endif message_size = 0; header=0; RESETheader_timer = 0; j=3; crc = 0; } // таймер ожидания байт (для успевания появления данных в буфере UART) if (!Delay && curmillis - timerdelay > waitbyte_RX) Delay = 1; // таймер сброса целостности сообщения (если данные оборвались посередине сообщения) if (RESETheader_timer && curmillis - prevRESETheader > 200) { #ifdef debugPCM Serial.println(F("Message fail timeout")); #endif RESETheader_timer = 0; header = 0;} // если нет ответа после запроса: +1 к счетчику неответов. Если накопилось 6 и более: делаем реинит. if (request!=INIT && NOanswer_timer && curmillis - prev_NOanswer > RequestPeriod - RequestPeriod/10) { NOanswer_timer = 0; noanswers++; if (noanswers>=6) { noanswers = 0; request = INIT; RequestPeriod = 3500;} } }// end receivePCM void Troublecodes () { if (MessageRx_PCM[n]==0x58 && MessageRx_PCM[n+1]==0x00){ myGLCD.clrScr(); drawscreen_three(); myGLCD.print("NO DTC", 165, 145); } // при получении сообщения о наличии ошибок DTC разберем сообщение выведем на экран ошибки if (MessageRx_PCM[n]==0x58 && MessageRx_PCM[n+1]>0){ myGLCD.clrScr(); drawscreen_three(); for (int i=0; i<MessageRx_PCM[n+8-7]; i++ ) { int y = i*35; bool nolA=0; bool nolB =0; if (!bitRead(MessageRx_PCM[n+11-7+(i*3)],6) && bitRead(MessageRx_PCM[n+11-7+(i*3)],7)){ myGLCD.setTextColor(GREEN, BLACK); myGLCD.print(" -Passive-", 300, (75+y));} // если DTC пасивныый делаем цвет зеленый if (bitRead(MessageRx_PCM[n+11-7+(i*3)],7) && bitRead(MessageRx_PCM[n+11-7+(i*3)],6)) { myGLCD.setTextColor(RED, BLACK); myGLCD.print(" -Active-", 300, (75+y));} // если DTC активный, делаем цвет красный myGLCD.print("ERROR ", 50, (75+y)); myGLCD.printNumI((i+1), 150, (75+y)); if (!bitRead(MessageRx_PCM[n+9-7+(i*3)],6) && !bitRead(MessageRx_PCM[n+9-7+(i*3)],7)) myGLCD.print(": P", 170, (75+y)); if (bitRead(MessageRx_PCM[n+9-7+(i*3)],6) && !bitRead(MessageRx_PCM[n+9-7+(i*3)],7)) myGLCD.print(": C", 170, (75+y)); if (!bitRead(MessageRx_PCM[n+9-7+(i*3)],6) && bitRead(MessageRx_PCM[n+9-7+(i*3)],7)) myGLCD.print(": B", 170, (75+y)); if (bitRead(MessageRx_PCM[n+9-7+(i*3)],6) && bitRead(MessageRx_PCM[n+9-7+(i*3)],7)) myGLCD.print(": U", 170, (75+y)); if (MessageRx_PCM[n+9-7+(i*3)]==0x00) {myGLCD.print("00", 230, (75+y)); nolA = 1;} if (MessageRx_PCM[n+9-7+(i*3)]<=0x0F&&MessageRx_PCM[n+9-7+(i*3)]!=0) {myGLCD.print("0", 230, (75+y)); nolA = 1;} if (nolA)myGLCD.print(String (MessageRx_PCM[n+9-7+(i*3)],HEX), 246, (75+y)); else myGLCD.print(String (MessageRx_PCM[n+9-7+(i*3)],HEX), 230, (75+y)); if (MessageRx_PCM[n+10-7+(i*3)]==0x00) {myGLCD.print("00", 262, (75+y)); nolB = 1;} if (MessageRx_PCM[n+10-7+(i*3)]<=0x0F&&MessageRx_PCM[n+10-7+(i*3)]!=0) {myGLCD.print("0", 262, (75+y)); nolB = 1;} if (nolB)myGLCD.print(String (MessageRx_PCM[n+10-7+(i*3)]),HEX, 278, (75+y)); else myGLCD.print(String (MessageRx_PCM[n+10-7+(i*3)],HEX), 262, (75+y));}} request = PRESENT; RequestPeriod = 4000; prevRequest = curmillis; } void dataVars() { //Barom = MessageRx_PCM[39]; L100 = (float)LHor*100.0/(float)Speed; LHor = (float)RPM* (float)InjQua*2.00/1000.0*60.00/1000.0/0.85; MAF = ((MessageRx_PCM[n+22]*256)+MessageRx_PCM[n+23])/10; BoostPres = ((MessageRx_PCM[n+24]*256)+MessageRx_PCM[n+25])/1000.0; RPM = (MessageRx_PCM[n+35-7]*256)+MessageRx_PCM[n+36-7]; EGRmg = ((MessageRx_PCM[n+37-7]*256)+MessageRx_PCM[n+38-7])/10.0; BoostPresCom = ((MessageRx_PCM[n+41-7]*256)+MessageRx_PCM[n+42-7])/1000.0; Speed = ((MessageRx_PCM[n+47-7]*256)+MessageRx_PCM[n+48-7])/100; DesaInjQua = ((MessageRx_PCM[n+53-7]*256)+MessageRx_PCM[n+54-7])/100.0; InjQua = ((MessageRx_PCM[n+55-7]*256)+MessageRx_PCM[n+56-7])/100.0; StaDaliv = ((MessageRx_PCM[n+57-7]*256)+MessageRx_PCM[n+58-7])/100.0; PumpRPM = (MessageRx_PCM[n+59-7]*256)+MessageRx_PCM[n+60-7]; EGRPul = ((MessageRx_PCM[n+65-7]*256)+MessageRx_PCM[n+66-7])/100.0; SolenPul = ((MessageRx_PCM[n+67-7]*256)+MessageRx_PCM[n+68-7])/100.0; SolenPre = ((MessageRx_PCM[n+73-7]*256)+MessageRx_PCM[n+74-7])/100.0; DesInj = ((MessageRx_PCM[n+75-7]*3)+(MessageRx_PCM[n+76-7])/100.0)+0.3; ActInj = ((MessageRx_PCM[n+19-7]*3)+(MessageRx_PCM[n+20-7])/100.0)+0.3; //TempAir = ((MessageRx_PCM[n+77-7]*26)-278)+MessageRx_PCM[n+78-7]/10.0; //Temp = ((MessageRx_PCM[n+17-7]*26)-278)+MessageRx_PCM[n+18-7]/10.0; //TempOil = ((MessageRx_PCM[n+21-7]*26)-278)+MessageRx_PCM[n+22-7]/10.0; //TempFuel = ((MessageRx_PCM[n+61-7]*26)-278)+MessageRx_PCM[n+62-7]/10.0; //ниже идут расчетные формулы более точные чем те что закоментированы выше int A = 0; if (MessageRx_PCM[n+77-7]<=0x0A) A = 277; if (MessageRx_PCM[n+77-7]==0x0B || MessageRx_PCM[n+77-7]==0x0C) A = 278; if (MessageRx_PCM[n+77-7]>=0x0D) A = 279; double B = MessageRx_PCM[n+78-7]/10.0; double cel , drob ; drob = modf(B, &cel); if (drob>0.6) cel++; TempAir = ((MessageRx_PCM[n+77-7]*26)-A)+cel; if (MessageRx_PCM[n+17-7]<=0x0A) A = 277; if (MessageRx_PCM[n+17-7]==0x0B || MessageRx_PCM[n+17-7]==0x0C) A = 278; if (MessageRx_PCM[n+17-7]>=0x0D) A = 279; B = MessageRx_PCM[n+18-7]/10.0; drob = modf(B, &cel); if (drob>0.6) cel++; Temp = ((MessageRx_PCM[n+17-7]*26)-A)+cel; if (MessageRx_PCM[n+21-7]<=0x0A) A = 277; if (MessageRx_PCM[n+21-7]==0x0B || MessageRx_PCM[n+21-7]==0x0C) A = 278; if (MessageRx_PCM[n+21-7]>=0x0D) A = 279; B = MessageRx_PCM[n+22-7]/10.0; drob = modf(B, &cel); if (drob>0.6) cel++; TempOil = ((MessageRx_PCM[n+21-7]*26)-A)+cel; if (MessageRx_PCM[n+61-7]<=0x0A) A = 277; if (MessageRx_PCM[n+61-7]==0x0B || MessageRx_PCM[n+61-7]==0x0C) A = 278; if (MessageRx_PCM[n+61-7]>=0x0D) A = 279; B = MessageRx_PCM[n+62-7]/10.0; drob = modf(B, &cel); if (drob>0.6) cel++; TempFuel = ((MessageRx_PCM[n+61-7]*26)-A)+cel; //---------------------------------------------------------- //страниц HOME //---------------------------------------------------------- //myGLCD.setBackColor(RED); myGLCD.setTextColor(WHITE, BLACK); //myGLCD.setBackColor(RED); myGLCD.printNumI(Speed, 350, 7, 3); if (currentPage == '0') { if (LHor != LHor_last || reNew) {myGLCD.printNumF(LHor, 1, 60, 40, '.',5); LHor_last=LHor;} if (L100 != L100_last || reNew) {myGLCD.printNumF(L100, 1, 210, 40,'.',5 ); L100_last=L100;} if (L100M != L100M_last || reNew) {myGLCD.printNumF(L100M, 1, 60, 75,'.',5 ); L100M_last=L100M;} if (L100SR_TFT != L100SR_TFT_last || reNew) {myGLCD.printNumF(L100SR_TFT, 1, 210, 75,'.',5 ); L100SR_TFT_last=L100SR_TFT;} if (kmREFUELING != kmREFUELING_last || reNew) {myGLCD.printNumI(kmREFUELING, 60, 110,5 ); kmREFUELING_last=kmREFUELING;} //if (Fuel<53) if (Fuel != Fuel_last || reNew) {myGLCD.printNumF(Fuel, 1, 210, 110,'.',5); Fuel_last=Fuel;} //else myGLCD.print("MAX", 210, 110); if (kmTrip != kmTrip_last || reNew) {myGLCD.printNumF(kmTrip, 1, 60, 145,'.',5); kmTrip_last=kmTrip;} if (FuelTrip != FuelTrip_last || reNew) {myGLCD.printNumF(FuelTrip, 1, 210, 145,'.',5); FuelTrip_last=FuelTrip;} if (PumpRPM != PumpRPM_last || reNew) {myGLCD.printNumI(PumpRPM, 210, 180,5); PumpRPM_last=PumpRPM;} if (RPM != RPM_last || reNew) {myGLCD.printNumI(RPM, 210, 215,5); RPM_last=RPM;} if (Fuel2 != Fuel2_last || reNew) {myGLCD.printNumF(Fuel2, 1, 0, 215,'.',5); Fuel2_last=Fuel2;} if (Temp != Temp_last || reNew) {myGLCD.printNumI(Temp, 415, 40, 3); Temp_last=Temp;} if (TempOil != TempOil_last || reNew) {myGLCD.printNumI(TempOil, 415, 75, 3); TempOil_last=TempOil;} if (TempFuel != TempFuel_last || reNew) {myGLCD.printNumI(TempFuel, 415, 110,3); TempFuel_last=TempFuel;} //myGLCD.printNumI(sensors.getTempCByIndex(0), 415, 145 , 3); if (t != t_last || reNew) {myGLCD.printNumI(t, 415, 180, 3); t_last=t;} if (TempAir != TempAir_last || reNew) {myGLCD.printNumI(TempAir, 415, 215, 3); TempAir_last=TempAir;} } //---------------------------------------------------------- //страниц INF1 //---------------------------------------------------------- if (currentPage == '1') { if (StaDaliv != StaDaliv_last || reNew) {myGLCD.printNumF(StaDaliv,1, 360, 40,'.', 3); StaDaliv_last=StaDaliv;} if (DesInj != DesInj_last || reNew) {myGLCD.printNumF(DesInj,1, 395, 75, '.', 4); DesInj_last=DesInj;} if (ActInj != ActInj_last || reNew) {myGLCD.printNumF(ActInj,1, 395, 110,'.', 4); ActInj_last=ActInj;} if (DesaInjQua != DesaInjQua_last || reNew) {myGLCD.printNumF(DesaInjQua,1, 395, 145,'.', 4);DesaInjQua_last=DesaInjQua;} if (InjQua != InjQua_last || reNew) {myGLCD.printNumF(InjQua,1, 395, 180,'.', 4); InjQua_last=InjQua;} if (MAF != MAF_last || reNew) {myGLCD.printNumI(MAF, 170, 215, 4); MAF_last=MAF;} if (h != h_last || reNew) {myGLCD.printNumF(h, 1, 418, 215); h_last=h;} } //---------------------------------------------------------- //страниц INF2 //---------------------------------------------------------- if (currentPage == '2') { if (BoostPres != BoostPres_last || reNew) {myGLCD.printNumF(BoostPres,1, 395, 40,'.', 4); BoostPres_last=BoostPres;} if (BoostPresCom != BoostPresCom_last || reNew) {myGLCD.printNumF(BoostPresCom,1, 395, 75,'.', 4); BoostPresCom_last=BoostPresCom;} if (EGRmg != EGRmg_last || reNew) {myGLCD.printNumI(EGRmg, 395, 110, 4); EGRmg_last=EGRmg;} if (EGRPul != EGRPul_last || reNew) {myGLCD.printNumF(EGRPul,1, 410, 145,'.', 3); EGRPul_last=EGRPul;} if (SolenPul != SolenPul_last || reNew) {myGLCD.printNumF(SolenPul, 1, 395, 180,'.', 4); SolenPul_last=SolenPul;} if (SolenPre != SolenPre_last || reNew) {myGLCD.printNumF(SolenPre, 0, 410, 215,'.', 3); SolenPre_last=SolenPre;} } } void sendMessagePCM(const byte &command) { #ifdef debugPCM Serial.print (F("Send request ")); Serial.print (textRequest[command]); Serial.print (F(" to PCM ")); Serial.println (millis()); #endif if (command != INIT) {NOanswer_timer = 1; prev_NOanswer = curmillis;} //т.к. сейчас будем делать запрос, то запускаем таймер контроля неответов byte size = PCM_Message_TX[command][0]; const byte siZe = size+4; byte Mes[siZe]; byte Checksum = 0; for(byte i=0; i<siZe; i++) { if (i==0) {Mes[i]=size; bitWrite(Mes[i], 7 , 1);} if (i==1) Mes[i] = PCM_address; if (i==2) Mes[i] = DIAG_address; if (i==3) {for (byte t=1; t<size+1; t++ ) { Mes[i]=PCM_Message_TX [command][t]; Checksum+=Mes[i] ; K_LINE_PCM.write (Mes[i]); if (command == INIT) delay (5); else delay (delaybyte_TX); K_LINE_PCM.read(); i++;}} if (i!=siZe-1) Checksum+=Mes[i]; else Mes[i] = Checksum; K_LINE_PCM.write (Mes[i]); if (command == INIT) delay (5); else delay (delaybyte_TX); K_LINE_PCM.read(); } }// end sendMessagePCM #if defined debugPCM or debugGAUGE void printDebugRX (const byte &inbyte) {if (inbyte<=15) Serial.print(F("0")); Serial.print (inbyte, HEX); Serial.print (F(" "));} #endif #ifdef debugPCM void printDebugRX_CSgood(){ if (MessageRx_PCM[n]==0xC1 && MessageRx_PCM[n+1]==0x6B && MessageRx_PCM[n+2]==0x8F) {Serial.println (F(" Initialization OK!!!!")); } else if (MessageRx_PCM[n]==0x58 && MessageRx_PCM[n+1]==0x00) {Serial.println (F(" NO DTC "));} else if (MessageRx_PCM[n]==0x58 && MessageRx_PCM[n+1] >0x00) {Serial.println (F(" DTC is found!"));} else if (MessageRx_PCM[n]==0x54 && MessageRx_PCM[n+1]==0xFF && MessageRx_PCM[n+2]==0x00){Serial.println (F(" DTC CLEARED "));} else if (MessageRx_PCM[n]==0x61 && MessageRx_PCM[n+1]==0x01) {Serial.println (F(" Receive PCM DATAstream"));}} #endif void Menu () { TouchHOME(); if (currentPage == '0') { TouchINF1(); TouchINF2(); TouchCHECK(); } if (currentPage == '1') { TouchINF2(); TouchCHECK(); } if (currentPage == '2') { TouchINF1(); TouchCHECK(); } if (currentPage == '3') { TouchREAD(); TouchERASE(); }} void drawHomeScreen() { reNew = 1; line() ; Watch (); myGLCD.print("/", 115, 7); myGLCD.print("/", 160, 7); myGLCD.setTextColor(RED, BLACK); // цвет линии и текста красный myGLCD.drawLine(295,35,295,248); // линия вертикальная myGLCD.drawLine(145,35,145,178); // линия вертикальная myGLCD.drawLine(80,178,80,247); // линия вертикальная myGLCD.print("L/H", 10, 40); myGLCD.print("L/A", 148, 40); myGLCD.print("L/V", 10, 75); myGLCD.print("L/M", 148, 75); myGLCD.print("D/K", 10, 110); myGLCD.print("D/L", 148, 110); myGLCD.print("V/K", 10, 145); myGLCD.print("V/L", 148, 145); myGLCD.print("PUMP RPM", 82, 180); myGLCD.print("ENGI RPM", 82, 215); myGLCD.print("D/La", 10, 180); myGLCD.print("Motor C", 300, 40); myGLCD.print("OIL C", 300, 75); myGLCD.print("FUEL C", 300, 110); myGLCD.print("INTER C", 300, 145); myGLCD.print("EXTER C", 300, 180); myGLCD.print("INTAIR C", 300, 215); //myGLCD.setTextColor(RED); myGLCD.drawRoundRect (15, 255, 145, 310); myGLCD.print("INF 1", 55, 270); myGLCD.drawRoundRect (175, 255, 305, 310); myGLCD.print("INF 2", 215, 270); myGLCD.drawRoundRect (335, 255, 465, 310); myGLCD.print("CHECK", 365, 270); myGLCD.drawRoundRect (1, 1, 77, 37); myGLCD.print("HOME", 10, 7); myGLCD.print("Km/h", 410, 7); } //------------------------------------------------- void drawscreen_one() { reNew = 1; line() ; Watch (); myGLCD.print("/", 115, 7); myGLCD.print("/", 160, 7); myGLCD.setTextColor(RED, BLACK); // цвет линии и текста красный myGLCD.print("Start of Delivery *CA:", 10, 40); myGLCD.print("Desir inject Start *CA:", 10, 75); myGLCD.print("Actua Inject Start *CA:", 10, 110); myGLCD.print("Desir Inject Quan mg/s:", 10, 145); myGLCD.print("Actu Inject Quant mg/s:", 10, 180); myGLCD.print("MAF mg/s:", 10, 215); myGLCD.print("Humedad %:", 255, 215); //myGLCD.setTextColor(RED); myGLCD.drawRoundRect (175, 255, 305, 310); myGLCD.print("INF 2", 215, 270); myGLCD.drawRoundRect (335, 255, 465, 310); myGLCD.print("CHECK", 365, 270); myGLCD.drawRoundRect (1, 1, 77, 37); myGLCD.print("HOME", 10, 7); myGLCD.print("Km/h", 410, 7); } //------------------------------------------------- void drawscreen_two() { reNew = 1; line() ; Watch (); myGLCD.print("/", 115, 7); myGLCD.print("/", 160, 7); myGLCD.setTextColor(RED, BLACK); // цвет линии и текста красный myGLCD.print("Boost Press Bar:", 10, 40); myGLCD.print("Boost Press Com Bar:", 10, 75); myGLCD.print("EGR command mg/s:", 10, 110); myGLCD.print("EGR Pulse Ratio %:", 10, 145); myGLCD.print("Solenoide Pulse %:", 10, 180); myGLCD.print("Solenoide Boost %:", 10, 215); //myGLCD.setColor(RED); myGLCD.drawRoundRect (15, 255, 145, 310); myGLCD.print("INF 1", 55, 270); myGLCD.drawRoundRect (335, 255, 465, 310); myGLCD.print("CHECK", 365, 270); myGLCD.drawRoundRect (1, 1, 77, 37); myGLCD.print("HOME", 10, 7); myGLCD.print("Km/h", 410, 7); } //---------------------------------------------------------------------------- void drawscreen_three() { reNew = 1; Watch (); myGLCD.print("/", 115, 7); myGLCD.print("/", 160, 7); myGLCD.setTextColor(RED, BLACK); // цвет линии красный myGLCD.drawLine(1,35,479,35); // линия горизонтальная myGLCD.drawLine(1,248,479,248); // линия горизонтальная //myGLCD.setTextColor(RED); myGLCD.drawRoundRect (15, 255, 145, 310); myGLCD.print("ERASE", 55, 270); myGLCD.drawRoundRect (335, 255, 465, 310); myGLCD.print("READ", 365, 270); myGLCD.drawRoundRect (1, 1, 77, 37); myGLCD.print("HOME", 10, 5); } ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////// //кнопки тач . координаты и переходы ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////// void TouchHOME(){ TSPoint p = ts.getPoint(); pinMode(XM, OUTPUT); pinMode(YP, OUTPUT); if (p.z > 10 && p.z < 1000) {if (p.x > 140 && p.x < 320 && p.y > 140 && p.y < 260 && p.z > MINPRESSURE && p.z < MAXPRESSURE) { myGLCD.drawRoundRect (1, 1, 77, 37); currentPage = '0'; request = PID; RequestPeriod = 10; prevRequest = curmillis; // на PCM в этом окне посылается запрос текущих параметров myGLCD.clrScr(); drawHomeScreen(); x = 0; y = 0; p.z = 0;}}} void TouchINF1(){ TSPoint p = ts.getPoint(); pinMode(XM, OUTPUT); pinMode(YP, OUTPUT); if (p.z > 10 && p.z < 1000) { if (p.x > 150 && p.x < 450 && p.y > 770 && p.y < 890 && p.z > MINPRESSURE && p.z < MAXPRESSURE) { myGLCD.drawRoundRect (15, 255, 145, 310); currentPage = '1'; request = PID; RequestPeriod = 10; prevRequest = curmillis; // на PCM в этом окне посылается запрос текущих параметров myGLCD.clrScr(); drawscreen_one(); x = 0; y = 0; p.z = 0;}}} void TouchINF2(){ TSPoint p = ts.getPoint(); pinMode(XM, OUTPUT); pinMode(YP, OUTPUT); if (p.z > 10 && p.z < 1000) { if (p.x > 450 && p.x < 680 && p.y > 770 && p.y < 890 && p.z > MINPRESSURE && p.z < MAXPRESSURE) { myGLCD.drawRoundRect (175, 255, 305, 310); currentPage = '2'; request = PID; RequestPeriod = 600; prevRequest = curmillis; // на PCM в этом окне посылается запрос текущих параметров myGLCD.clrScr(); drawscreen_two(); x = 0; y = 0; p.z = 0;}}} void TouchCHECK(){ TSPoint p = ts.getPoint(); pinMode(XM, OUTPUT); pinMode(YP, OUTPUT); if (p.z > 10 && p.z < 1000) { if (p.x > 690 && p.x < 950 && p.y > 770 && p.y < 890 && p.z > MINPRESSURE && p.z < MAXPRESSURE) { myGLCD.drawRoundRect (335, 255, 465, 310); currentPage = '3'; // request = DTCREAD; RequestPeriod = 10; prevRequest = curmillis; // на PCM в этом окне посылается запрос чтения ошибок myGLCD.clrScr(); drawscreen_three(); x = 0; y = 0; p.z = 0;}}} void TouchREAD(){ TSPoint p = ts.getPoint(); pinMode(XM, OUTPUT); pinMode(YP, OUTPUT); if (p.z > 10 && p.z < 1000) { if (p.x > 690 && p.x < 950 && p.y > 770 && p.y < 890 && p.z > MINPRESSURE && p.z < MAXPRESSURE) { myGLCD.drawRoundRect (335, 255, 465, 310); request = DTCREAD; RequestPeriod = 300; prevRequest = curmillis; // на PCM при нажатии этой кнопки посылается запрос чтения ошибок x = 0; y = 0; p.z = 0;}}} void TouchERASE(){ TSPoint p = ts.getPoint(); pinMode(XM, OUTPUT); pinMode(YP, OUTPUT); if (p.z > 10 && p.z < 1000) { if (p.x > 150 && p.x < 450 && p.y > 770 && p.y < 890 && p.z > MINPRESSURE && p.z < MAXPRESSURE) {myGLCD.drawRoundRect (15, 255, 145, 310); request = DTCERASE; RequestPeriod = 300; prevRequest = curmillis; // на PCM при нажатии этой кнопки посылается запрос удаления ошибок x = 0; y = 0; p.z = 0;}}} //////////////////////////////////////////////////////////////////////////////////////// //прорисовка линий /////////////////////////////////////////////////////////////////////////////////////// void line() { //myGLCD.setTextColor(RED); // цвет линии красный myGLCD.drawLine(1,35,479,35); // линия горизонтальная myGLCD.drawLine(1,73,479,73); // линия горизонтальная myGLCD.drawLine(1,108,479,108); // линия горизонтальная myGLCD.drawLine(1,143,479,143); // линия горизонтальная myGLCD.drawLine(1,178,479,178); // линия горизонтальная myGLCD.drawLine(1,212,479,212); // линия горизонтальная myGLCD.drawLine(1,248,479,248); // линия горизонтальная } void Watch (){ DateTime now = rtc.now(); int minut = now.minute(); int hour = now.hour(); int mon = now.month(); int date = now.day(); int Year = now.year(); static int minut_last; static int hour_last; static int mon_last; static int date_last; static int Year_last; myGLCD.setTextColor(WHITE, BLACK); //белый цвет цифры if (date != date_last || reNew){ myGLCD.printNumI(date, 85, 7, 2, '0'); date_last = date; } if (mon!=mon_last || reNew){myGLCD.printNumI(date, 130, 7, 2, '0'); mon_last = mon; } if (Year!=Year_last || reNew) { myGLCD.printNumI(Year, 175, 7); Year_last = Year; } if (hour!=hour_last || reNew){ myGLCD.printNumI(date, 255, 7, 2, '0'); hour_last = hour; } if (minut!=minut_last || reNew ){ myGLCD.printNumI(date, 300, 7, 2, '0'); minut_last = minut; } reNew = 0; }Во всех строках надо наверное добавить скобки:
было:
if(SolenPre != SolenPre_last || reNew) {myGLCD.printNumF(SolenPre, 0, 410, 215,'.', 3); SolenPre_last=SolenPre;}стало:
if((SolenPre != SolenPre_last) || reNew) {myGLCD.printNumF(SolenPre, 0, 410, 215,'.', 3); SolenPre_last=SolenPre;}и в 517 дописать:
reNew = 0;
а в 821 убрать:
reNew = 0;
И ещё один косяк вижу:
Там где ты обьявлял новые переменные ..._last - типы должны совпадать ! Где int, то и новая int. Где float, то и новая float !!! (а то ты кур к свиньям приравниваешь)
nvidia нервно курит в сторонке )
MaksVV по какой шине подключен дисплей ?
не могу знать
:-) как проктологи - автомеханики
меняем кольца в двигателе через выхлопную трубу ...
может он и2ц? вот и тормозит
нет , это называется чиним по фотографии
Я фото не видел ... видел тоолько картинку на дисплее ...
Viki, может всё таки закажешь этот, а то реально ппц тема уже на две тыщи постов раздувается. Может этот тфт побыстрее будет. Только спросить у китайца с какой либой работает.
Не, уже победа. обновление 1 секудна. даже вроде чутка меньше :) одни косяк. время и дата не коректны. показывает 02/02/2019 02:02. перезалил время и дату думал просто сбилось. но нет тоже самое 02/02/2019 02:02
#include <Adafruit_GFX.h> #include <MCUFRIEND_kbv.h> #include <UTFTGLUE.h>//use GLUE class and constructor #include "TouchScreen.h" #include <stdint.h> #include <SPI.h> #include <EEPROM.h> //MCUFRIEND_kbv tft; #include "Fonts/Chosence_Bold16pt7b.h"; #define MINPRESSURE 200 #define MAXPRESSURE 1000 //pin 20 SCL , 21 SDA датчик реального времени #include <Wire.h> #include "RTClib.h" RTC_DS3231 rtc; UTFTGLUE myGLCD(0x1581,A2,A1,A3,A4,A0); //all dummy args const int XP = 6, XM = A2, YP = A1, YM = 7; const int TS_LEFT = 136, TS_RT = 907, TS_TOP = 139, TS_BOT = 942; TouchScreen ts = TouchScreen(XP, YP, XM, YM, 300); uint16_t ID; int x, y; char currentPage; float h; int h_last = 1; float t; int t_last = 1; bool Dvoet = 0; bool reNew = 0; #define BLACK 0x0000 #define WHITE 0xFFFF #define RED 0xF800 #define GREEN 0x07E0 #include <SoftwareSerial.h> #define TX_PCM 13 SoftwareSerial K_LINE_PCM (12, TX_PCM); //RХ,TХ #define PCM_address 0x11 // адрес PCM #define DIAG_address 0xF1 // адрес диагностики #define debugPCM // раскоментировать эту строку для отладки в Serial порту обмена с PCM //#define debugGAUGE // раскоментировать эту строку для отладки в Serial порту обмена co щитком приборов uint32_t curmillis = 0; // снимок текущего времени uint32_t prevRequest = 0; // таймер периодических запосов на PCM uint16_t RequestPeriod = 3500; // периодичность запросов на PCM uint32_t prevRESETheader=0; // таймер сброса сообщения, если данные оборвались посередине сообщения bool RESETheader_timer; // таймер сброса сообщения, если данные оборвались посередине сообщения uint32_t prev_NOanswer=0; // таймер контроля неответов от ЭБУ после подачи запросов bool NOanswer_timer = 0; // таймер контроля неответов от ЭБУ после подачи запросов byte noanswers = 0; // количество подряд неответов от ЭБУ uint32_t timerdelay = 0; // таймер ожидания байт (для успевания появления данных в буфере UART) bool Delay = 0; // таймер ожидания байт (для успевания появления данных в буфере UART) byte waitbyte_RX = 1; // задержка, мс для успевания появления данных в буфере RX // (подрегулировать в зависимости от уровня жизнидеятельности на Марсе) #define TIMER_DELAY Delay = 0; timerdelay = curmillis // включение этого таймера byte delaybyte_TX = 1; // задержка между отправкой байт в запросах, мс byte header = 0; // состояние заголовка byte message_size = 0; // размер тела сообщения byte j = 3; // инкремент byte n = 3; // количество старт байт const byte bufsize = 150; // размер буфера принятого сообщения byte MessageRx_PCM [bufsize] = {0}; // буфер принятого сообщения byte crc =0; // байт контрольной суммы // возможные варианты запросов на ЭБУ: enum REQUEST { INIT, PID, DTCERASE, DTCREAD, PRESENT, }; // текстовки запросов для отладки char* textRequest[] = { "INIT", "PID_2101", "DTC_ERASE", "DTC_READ", "PRESENT", } ; // сами запросы byte PCM_Message_TX[][5] = { {1, 0x81, 0,0,0}, // запрос инициализации {2, 0x21,0x01, 0,0}, // запрос пид 2101 {3, 0x14,0xFF,0x00, 0}, // запрос на стирание ошибок {4, 0x18,0x00,0xFF,0x00 }, // запрос на чтение ошибок {1, 0x3E, 0,0,0}, // запрос присутствия }; byte request = INIT; // переменная, показывающая какой запрос будем делать //-------------------------------------------переменные бортовика float L100M = 0; float L100M_last = 1; //расход на 100 км измеренный за поездку float L100 = 0; float L100_last = 1; //мгновенный расход литров на 100км float LHor = 0; float LHor_last = 1; //мгновенный расход топлива литров в час float L100SR = 0; //расход литров на 100км измеренный раз в интервал kmL float L100SR_TFT = 0; float L100SR_TFT_last = 1; // самый средний из расходов на 100км, он выводится на экран int L100_Eeprom[11]= {10,10,10,10,10,10,10,10,10,10,10}; int FuelZamer[10]= {0}; // массив для измерения уровня (количества) топлива int ZamerNumber = 0; // номер замера уровня (количества) топлива int n_eeprom = 0; // текущий адрес ячейки еепром для записи расхода int MAF = 0; int MAF_last = 1; //26,27 байты Sensor de flujo de aire en masa float BoostPres = 0; float BoostPres_last = 1; //28,29 байты Presión de refuerzo int RPM = 0; int RPM_last = 1; //32,33 байты Velocidad del motor int EGRmg = 0; int EGRmg_last = 1; //34,35 байты Comando EGR (Comando de recirculación de gases de escape) float BoostPresCom = 0; float BoostPresCom_last = 1; //38,39 байты Comando de presión de refuerzo int Speed = 0; int Speed_last = 1; //44,45 байты Velocidad del vehículo float DesaInjQua = 0; float DesaInjQua_last = 1; //50,51 байты Cantidad de inyección deseada float InjQua = 0; float InjQua_last = 1; //52,53 байты Cantidad de la inyección float StaDaliv = 0; float StaDaliv_last = 1; //54,55 байты Inicio de la entrega int PumpRPM = 0; int PumpRPM_last = 1; //56,57 байты Velocidad de la bomba float EGRPul = 0; float EGRPul_last = 1; //62,63 байты Relación de impulsos EGR (recirculación de gases de escape float SolenPul = 0; float SolenPul_last = 1; //64,65 байты Velocidad de solenoide de control de nivel de remolino Relación de impulsos float SolenPre = 0; float SolenPre_last = 1; //70,71 байты Relación de impulsos Presión Electroválvula de presión float DesInj = 0; float DesInj_last = 1; //72,73 байты Inyección deseada Inicio float ActInj = 0; float ActInj_last = 1; //16,17 байты Inicio de la inyección real int TempAir = 0; int TempAir_last = 1; //74,75 байты Temperatura del aire de admisión int Temp = 0; int Temp_last = 1; //14,15 байты Temperatura del refrigerante int TempOil = 0; int TempOil_last = 1; //18,19 байты Temperatura del aceite del motor int TempFuel = 0; int TempFuel_last = 1; //58,59 байты Temperatura del combustible //все что касается топлива float Fuel = 0; //остаток топлива float Fuel2 = 0; float Fuel2_last = 1; //остаток мгновенного топлива байт 16 , датчика в баке int FuelIGN = 0; // количество топлвива в баке на момент включения зажигания int Fuel_last = 0; // для формул bool flagFuelIGN = 0; // флаг записан ли остаток топлива в момент вкл. зажигания float FuelTrip = 0; float FuelTrip_last = 1; // количество литров топлива, израсходованное за один цикл включения зажигания //все что касается километража float kmAge = 0; //пробег, полученный со щитка приборов int kmAgeIGN = 0; //пробег который был в момент включения зажигания int kmAge_last = 0; // для формул bool flagkmAgeIGN = 0; //флаг записан ли пробег в момент вкл. зажигания float kmTrip = 0; float kmTrip_last = 1; //пробег за один цикл включения зажигания int kmL = 10; // интервал, через который будет происходить обновление среднего расхода на 100км int km = 0; // переменная для расчетов int kmeeprom = 10; // интервал, через который будет происходить подсчет среднеарифмитического расхода L100SR_TFT int kmTFT = 0; // переменная для расчетов периодического подсчета среднеарифмитического расхода топлива L100SR_TFT int kmREFUELING = 0; int kmREFUELING_last = 1; // пробег до заправки на остатке топлива unsigned long prevWatch = 0; unsigned long prevDvoet = 0; unsigned long prevData = 0; void setup() { uint16_t ID = myGLCD.readID(); if (ID == 0xD3D3) ID = 0x1581; // write-only shield myGLCD.begin(ID); myGLCD.InitLCD(3); myGLCD.clrScr(); myGLCD.setFont(&Chosence_Bold16pt7b); //myGLCD.fillScreen(WHITE); //myGLCD.setTextColor(WHITE, BLACK); //myGLCD.setBackColor(BLACK); Wire.begin(); rtc.begin(); //загрузка стартовой страницы currentPage = '0'; drawHomeScreen(); //подсчет среднеарифметического усредненного расхода for (int i = 0; i < 11; i++) L100_Eeprom [i]= EEPROM.read(i); for (int i = 0; i < 11; i++) L100SR_TFT = L100SR_TFT + L100_Eeprom [i]; L100SR_TFT = (float)L100SR_TFT/110.0; if (L100SR_TFT<0) L100SR_TFT = 0; if (L100SR_TFT>99) L100SR_TFT = 99; // строка ниже используется для настройки даты и времени часов // раскоментировать, выставить времая и дату, залить в ардуино. в скетче закоментировать // обратно и залить еще раз, иначе каждый раз будет по новой выствлятся это же время и дата // (год, месяц, день, часы, минуты, секунды) //rtc.adjust(DateTime(2019, 7, 2, 10, 48, 0)); #if defined debugPCM or debugGAUGE Serial.begin(115200); #endif K_LINE_PCM.begin(10400); pinMode(TX_PCM, OUTPUT); } void loop() { curmillis = millis(); // снимок текущего времени if (curmillis - prevRequest > RequestPeriod && header == 0 ) { if (request == INIT) fastinit(); // при необходимости делаем переподключение к PCM else {sendMessagePCM(request); // отправляем на PCM текущий запрос if (request == PID) RequestPeriod = 600; if (request == DTCERASE || request == DTCREAD) RequestPeriod = 2500;} prevRequest = curmillis; } receivePCM (); // приём сообщений от PCM if (header == 0) Menu (); if (curmillis - prevWatch > 3000) { Watch (); prevWatch = curmillis;} //if (curmillis - prevDvoet > 500) { if (!Dvoet) {myGLCD.setTextColor(WHITE); } else {myGLCD.setTextColor(BLACK); } myGLCD.print(":", 290, 5); prevDvoet = curmillis; Dvoet=!Dvoet;} }// end loop void fastinit() { digitalWrite (TX_PCM, HIGH); // bus idle delay(1500); digitalWrite (TX_PCM, LOW); // first part fastinit (25 ms LOW) delay(25); digitalWrite (TX_PCM, HIGH); // second part fastinit (25 ms HIGH) delay(25); K_LINE_PCM.begin(10400); sendMessagePCM(INIT); // send start communication message } void receivePCM () { if (K_LINE_PCM.available() ){ // первый старт байт if (header == 0 && Delay){TIMER_DELAY ; MessageRx_PCM[0]=K_LINE_PCM.read(); if (MessageRx_PCM[0]!=0xFF && bitRead (MessageRx_PCM[0],7)){header = 1; RESETheader_timer = 1; prevRESETheader = curmillis; #ifdef debugPCM Serial.print (F("Receive PCM: ")); printDebugRX(MessageRx_PCM[0]); #endif } } // второй старт байт if (header == 1 && Delay){TIMER_DELAY ; MessageRx_PCM[1]=K_LINE_PCM.read(); #ifdef debugPCM printDebugRX (MessageRx_PCM[1]); #endif if (MessageRx_PCM[1]==DIAG_address){ header = 2;} else { #ifdef debugPCM Serial.println(F(" PCM Message fail address")); #endif header = 0; RESETheader_timer = 0;}} // третий старт байт if (header == 2 && Delay){ TIMER_DELAY ; MessageRx_PCM[2]=K_LINE_PCM.read(); #ifdef debugPCM printDebugRX (MessageRx_PCM[2]); #endif if (MessageRx_PCM[2]==PCM_address){ message_size = MessageRx_PCM[0]; prevRESETheader = curmillis; if (MessageRx_PCM[0] !=0x80) {header = 4; bitWrite (message_size, 7 , 0);j=3;n=3;} else {header = 3; j=4;n=4;} if (message_size > bufsize) message_size = bufsize; crc = 0;} else {header = 0; #ifdef debugPCM Serial.println(F("PCM Message fail address")); #endif RESETheader_timer = 0;} } // если размер сообщения указан в дополнительном байте (нулевой байт 0x80) читаем этот дополнительный байт: if (header == 3 && Delay){ TIMER_DELAY ; prevRESETheader = curmillis; MessageRx_PCM[3]=K_LINE_PCM.read(); #ifdef debugPCM printDebugRX(MessageRx_PCM[3]); #endif message_size = MessageRx_PCM[3]; if (message_size > bufsize) message_size = bufsize; crc = 0; header = 4; } // пишем тело сообщения if (header == 4 && Delay && j< message_size+n+1) { MessageRx_PCM[j] = K_LINE_PCM.read(); prevRESETheader = curmillis; if (j<message_size+n) crc+= MessageRx_PCM[j]; // подсчёт КС if (j==message_size+n) header = 5; TIMER_DELAY ; #ifdef debugPCM printDebugRX(MessageRx_PCM[j]); #endif j++; } } // сообщение приняли, действуем if (header == 5) {TIMER_DELAY ; #ifdef debugPCM Serial.println(); #endif NOanswer_timer = 0; noanswers = 0; // сбрасываем таймер контроля неответов for(byte i = 0; i<n; i++) crc+=MessageRx_PCM[i]; // прибавляем к контрольной сумме старт байты // если контрольная сумма верна: if ( crc == MessageRx_PCM[message_size+n]) { #ifdef debugPCM Serial.print (F("Received message is OK! Checksum is correct!")); Serial.print (F(" ")); Serial.println (millis()); // Если КС совпала, тут чёнибудь нужное делаем printDebugRX_CSgood(); #endif if (MessageRx_PCM[n]==0xC1 && MessageRx_PCM[n+1]==0x6B && MessageRx_PCM[n+2]==0x8F) { if (currentPage!=3) {request = PID; RequestPeriod = 70;} else request = PRESENT, RequestPeriod = 4000; prevRequest = curmillis; // receive good INIT } else if (MessageRx_PCM[n]==0x58) Troublecodes (); // DTC else if (MessageRx_PCM[n]==0x54 && MessageRx_PCM[n+1]==0xFF && MessageRx_PCM[n+2]==0x00){ request = PRESENT; RequestPeriod = 4000; prevRequest = curmillis;} // DTC are cleared else if (MessageRx_PCM[n]==0x61 && MessageRx_PCM[n+1]==0x01) {dataVars() ; RequestPeriod = 70; prevRequest = curmillis; } // receive DataStream } // если контрольная сумма не совпала: #ifdef debugPCM else Serial.println("CRC fail!!!" ); #endif message_size = 0; header=0; RESETheader_timer = 0; j=3; crc = 0; } // таймер ожидания байт (для успевания появления данных в буфере UART) if (!Delay && curmillis - timerdelay > waitbyte_RX) Delay = 1; // таймер сброса целостности сообщения (если данные оборвались посередине сообщения) if (RESETheader_timer && curmillis - prevRESETheader > 200) { #ifdef debugPCM Serial.println(F("Message fail timeout")); #endif RESETheader_timer = 0; header = 0;} // если нет ответа после запроса: +1 к счетчику неответов. Если накопилось 6 и более: делаем реинит. if (request!=INIT && NOanswer_timer && curmillis - prev_NOanswer > RequestPeriod - RequestPeriod/10) { NOanswer_timer = 0; noanswers++; if (noanswers>=6) { noanswers = 0; request = INIT; RequestPeriod = 3500;} } }// end receivePCM void Troublecodes () { if (MessageRx_PCM[n]==0x58 && MessageRx_PCM[n+1]==0x00){ myGLCD.clrScr(); drawscreen_three(); myGLCD.print("NO DTC", 165, 145); } // при получении сообщения о наличии ошибок DTC разберем сообщение выведем на экран ошибки if (MessageRx_PCM[n]==0x58 && MessageRx_PCM[n+1]>0){ myGLCD.clrScr(); drawscreen_three(); for (int i=0; i<MessageRx_PCM[n+8-7]; i++ ) { int y = i*35; bool nolA=0; bool nolB =0; if (!bitRead(MessageRx_PCM[n+11-7+(i*3)],6) && bitRead(MessageRx_PCM[n+11-7+(i*3)],7)){ myGLCD.setTextColor(GREEN, BLACK); myGLCD.print(" -Passive-", 300, (75+y));} // если DTC пасивныый делаем цвет зеленый if (bitRead(MessageRx_PCM[n+11-7+(i*3)],7) && bitRead(MessageRx_PCM[n+11-7+(i*3)],6)) { myGLCD.setTextColor(RED, BLACK); myGLCD.print(" -Active-", 300, (75+y));} // если DTC активный, делаем цвет красный myGLCD.print("ERROR ", 50, (75+y)); myGLCD.printNumI((i+1), 150, (75+y)); if (!bitRead(MessageRx_PCM[n+9-7+(i*3)],6) && !bitRead(MessageRx_PCM[n+9-7+(i*3)],7)) myGLCD.print(": P", 170, (75+y)); if (bitRead(MessageRx_PCM[n+9-7+(i*3)],6) && !bitRead(MessageRx_PCM[n+9-7+(i*3)],7)) myGLCD.print(": C", 170, (75+y)); if (!bitRead(MessageRx_PCM[n+9-7+(i*3)],6) && bitRead(MessageRx_PCM[n+9-7+(i*3)],7)) myGLCD.print(": B", 170, (75+y)); if (bitRead(MessageRx_PCM[n+9-7+(i*3)],6) && bitRead(MessageRx_PCM[n+9-7+(i*3)],7)) myGLCD.print(": U", 170, (75+y)); if (MessageRx_PCM[n+9-7+(i*3)]==0x00) {myGLCD.print("00", 230, (75+y)); nolA = 1;} if (MessageRx_PCM[n+9-7+(i*3)]<=0x0F&&MessageRx_PCM[n+9-7+(i*3)]!=0) {myGLCD.print("0", 230, (75+y)); nolA = 1;} if (nolA)myGLCD.print(String (MessageRx_PCM[n+9-7+(i*3)],HEX), 246, (75+y)); else myGLCD.print(String (MessageRx_PCM[n+9-7+(i*3)],HEX), 230, (75+y)); if (MessageRx_PCM[n+10-7+(i*3)]==0x00) {myGLCD.print("00", 262, (75+y)); nolB = 1;} if (MessageRx_PCM[n+10-7+(i*3)]<=0x0F&&MessageRx_PCM[n+10-7+(i*3)]!=0) {myGLCD.print("0", 262, (75+y)); nolB = 1;} if (nolB)myGLCD.print(String (MessageRx_PCM[n+10-7+(i*3)]),HEX, 278, (75+y)); else myGLCD.print(String (MessageRx_PCM[n+10-7+(i*3)],HEX), 262, (75+y));}} request = PRESENT; RequestPeriod = 4000; prevRequest = curmillis; } void dataVars() { //Barom = MessageRx_PCM[39]; L100 = (float)LHor*100.0/(float)Speed; LHor = (float)RPM* (float)InjQua*2.00/1000.0*60.00/1000.0/0.85; MAF = ((MessageRx_PCM[n+22]*256)+MessageRx_PCM[n+23])/10; BoostPres = ((MessageRx_PCM[n+24]*256)+MessageRx_PCM[n+25])/1000.0; RPM = (MessageRx_PCM[n+35-7]*256)+MessageRx_PCM[n+36-7]; EGRmg = ((MessageRx_PCM[n+37-7]*256)+MessageRx_PCM[n+38-7])/10.0; BoostPresCom = ((MessageRx_PCM[n+41-7]*256)+MessageRx_PCM[n+42-7])/1000.0; Speed = ((MessageRx_PCM[n+47-7]*256)+MessageRx_PCM[n+48-7])/100; DesaInjQua = ((MessageRx_PCM[n+53-7]*256)+MessageRx_PCM[n+54-7])/100.0; InjQua = ((MessageRx_PCM[n+55-7]*256)+MessageRx_PCM[n+56-7])/100.0; StaDaliv = ((MessageRx_PCM[n+57-7]*256)+MessageRx_PCM[n+58-7])/100.0; PumpRPM = (MessageRx_PCM[n+59-7]*256)+MessageRx_PCM[n+60-7]; EGRPul = ((MessageRx_PCM[n+65-7]*256)+MessageRx_PCM[n+66-7])/100.0; SolenPul = ((MessageRx_PCM[n+67-7]*256)+MessageRx_PCM[n+68-7])/100.0; SolenPre = ((MessageRx_PCM[n+73-7]*256)+MessageRx_PCM[n+74-7])/100.0; DesInj = ((MessageRx_PCM[n+75-7]*3)+(MessageRx_PCM[n+76-7])/100.0)+0.3; ActInj = ((MessageRx_PCM[n+19-7]*3)+(MessageRx_PCM[n+20-7])/100.0)+0.3; //TempAir = ((MessageRx_PCM[n+77-7]*26)-278)+MessageRx_PCM[n+78-7]/10.0; //Temp = ((MessageRx_PCM[n+17-7]*26)-278)+MessageRx_PCM[n+18-7]/10.0; //TempOil = ((MessageRx_PCM[n+21-7]*26)-278)+MessageRx_PCM[n+22-7]/10.0; //TempFuel = ((MessageRx_PCM[n+61-7]*26)-278)+MessageRx_PCM[n+62-7]/10.0; //ниже идут расчетные формулы более точные чем те что закоментированы выше int A = 0; if (MessageRx_PCM[n+77-7]<=0x0A) A = 277; if (MessageRx_PCM[n+77-7]==0x0B || MessageRx_PCM[n+77-7]==0x0C) A = 278; if (MessageRx_PCM[n+77-7]>=0x0D) A = 279; double B = MessageRx_PCM[n+78-7]/10.0; double cel , drob ; drob = modf(B, &cel); if (drob>0.6) cel++; TempAir = ((MessageRx_PCM[n+77-7]*26)-A)+cel; if (MessageRx_PCM[n+17-7]<=0x0A) A = 277; if (MessageRx_PCM[n+17-7]==0x0B || MessageRx_PCM[n+17-7]==0x0C) A = 278; if (MessageRx_PCM[n+17-7]>=0x0D) A = 279; B = MessageRx_PCM[n+18-7]/10.0; drob = modf(B, &cel); if (drob>0.6) cel++; Temp = ((MessageRx_PCM[n+17-7]*26)-A)+cel; if (MessageRx_PCM[n+21-7]<=0x0A) A = 277; if (MessageRx_PCM[n+21-7]==0x0B || MessageRx_PCM[n+21-7]==0x0C) A = 278; if (MessageRx_PCM[n+21-7]>=0x0D) A = 279; B = MessageRx_PCM[n+22-7]/10.0; drob = modf(B, &cel); if (drob>0.6) cel++; TempOil = ((MessageRx_PCM[n+21-7]*26)-A)+cel; if (MessageRx_PCM[n+61-7]<=0x0A) A = 277; if (MessageRx_PCM[n+61-7]==0x0B || MessageRx_PCM[n+61-7]==0x0C) A = 278; if (MessageRx_PCM[n+61-7]>=0x0D) A = 279; B = MessageRx_PCM[n+62-7]/10.0; drob = modf(B, &cel); if (drob>0.6) cel++; TempFuel = ((MessageRx_PCM[n+61-7]*26)-A)+cel; //---------------------------------------------------------- //страниц HOME //---------------------------------------------------------- //myGLCD.setBackColor(RED); myGLCD.setTextColor(WHITE, BLACK); //myGLCD.setBackColor(RED); if ((Speed != Speed_last) || reNew) {myGLCD.printNumI(Speed, 350, 7, 4); Speed_last=Speed;} if (currentPage == '0') { if ((LHor != LHor_last) || reNew) {myGLCD.printNumF(LHor, 1, 60, 40, '.',5); LHor_last=LHor;} if ((L100 != L100_last) || reNew) {myGLCD.printNumF(L100, 1, 210, 40,'.',5 ); L100_last=L100;} if ((L100M != L100M_last) || reNew) {myGLCD.printNumF(L100M, 1, 60, 75,'.',5 ); L100M_last=L100M;} if ((L100SR_TFT != L100SR_TFT_last) || reNew) {myGLCD.printNumF(L100SR_TFT, 1, 210, 75,'.',5 ); L100SR_TFT_last=L100SR_TFT;} if ((kmREFUELING != kmREFUELING_last) || reNew) {myGLCD.printNumI(kmREFUELING, 60, 110,5 ); kmREFUELING_last=kmREFUELING;} //if (Fuel<53) if ((Fuel != Fuel_last) || reNew) {myGLCD.printNumF(Fuel, 1, 210, 110,'.',5); Fuel_last=Fuel;} //else myGLCD.print("MAX", 210, 110); if ((kmTrip != kmTrip_last) || reNew) {myGLCD.printNumF(kmTrip, 1, 60, 145,'.',5); kmTrip_last=kmTrip;} if ((FuelTrip != FuelTrip_last) || reNew) {myGLCD.printNumF(FuelTrip, 1, 210, 145,'.',5); FuelTrip_last=FuelTrip;} if ((PumpRPM != PumpRPM_last) || reNew) {myGLCD.printNumI(PumpRPM, 210, 180,5); PumpRPM_last=PumpRPM;} if ((RPM != RPM_last) || reNew) {myGLCD.printNumI(RPM, 210, 215,5); RPM_last=RPM;} if ((Fuel2 != Fuel2_last) || reNew) {myGLCD.printNumF(Fuel2, 1, 0, 215,'.',5); Fuel2_last=Fuel2;} if ((Temp != Temp_last) || reNew) {myGLCD.printNumI(Temp, 415, 40, 3); Temp_last=Temp;} if ((TempOil != TempOil_last) || reNew) {myGLCD.printNumI(TempOil, 415, 75, 3); TempOil_last=TempOil;} if ((TempFuel != TempFuel_last) || reNew) {myGLCD.printNumI(TempFuel, 415, 110,3); TempFuel_last=TempFuel;} //myGLCD.printNumI(sensors.getTempCByIndex(0), 415, 145 , 3); if ((t != t_last) || reNew) {myGLCD.printNumI(t, 415, 180, 3); t_last=t;} if ((TempAir != TempAir_last) || reNew) {myGLCD.printNumI(TempAir, 415, 215, 3); TempAir_last=TempAir;} } //---------------------------------------------------------- //страниц INF1 //---------------------------------------------------------- if (currentPage == '1') { if ((StaDaliv != StaDaliv_last) || reNew) {myGLCD.printNumF(StaDaliv,1, 360, 40,'.', 3); StaDaliv_last=StaDaliv;} if ((DesInj != DesInj_last) || reNew) {myGLCD.printNumF(DesInj,1, 395, 75, '.', 4); DesInj_last=DesInj;} if ((ActInj != ActInj_last) || reNew) {myGLCD.printNumF(ActInj,1, 395, 110,'.', 4); ActInj_last=ActInj;} if ((DesaInjQua != DesaInjQua_last) || reNew) {myGLCD.printNumF(DesaInjQua,1, 395, 145,'.', 4);DesaInjQua_last=DesaInjQua;} if ((InjQua != InjQua_last) || reNew) {myGLCD.printNumF(InjQua,1, 395, 180,'.', 4); InjQua_last=InjQua;} if ((MAF != MAF_last) || reNew) {myGLCD.printNumI(MAF, 170, 215, 4); MAF_last=MAF;} if ((h != h_last) || reNew) {myGLCD.printNumF(h, 1, 418, 215); h_last=h;} } //---------------------------------------------------------- //страниц INF2 //---------------------------------------------------------- if (currentPage == '2') { if ((BoostPres != BoostPres_last) || reNew) {myGLCD.printNumF(BoostPres,1, 395, 40,'.', 4); BoostPres_last=BoostPres;} if ((BoostPresCom != BoostPresCom_last) || reNew) {myGLCD.printNumF(BoostPresCom,1, 395, 75,'.', 4); BoostPresCom_last=BoostPresCom;} if ((EGRmg != EGRmg_last) || reNew) {myGLCD.printNumI(EGRmg, 395, 110, 4); EGRmg_last=EGRmg;} if ((EGRPul != EGRPul_last) || reNew) {myGLCD.printNumF(EGRPul,1, 410, 145,'.', 3); EGRPul_last=EGRPul;} if ((SolenPul != SolenPul_last) || reNew) {myGLCD.printNumF(SolenPul, 1, 395, 180,'.', 4); SolenPul_last=SolenPul;} if ((SolenPre != SolenPre_last) || reNew) {myGLCD.printNumF(SolenPre, 0, 410, 215,'.', 3); SolenPre_last=SolenPre;} } reNew = 0; } void sendMessagePCM(const byte &command) { #ifdef debugPCM Serial.print (F("Send request ")); Serial.print (textRequest[command]); Serial.print (F(" to PCM ")); Serial.println (millis()); #endif if (command != INIT) {NOanswer_timer = 1; prev_NOanswer = curmillis;} //т.к. сейчас будем делать запрос, то запускаем таймер контроля неответов byte size = PCM_Message_TX[command][0]; const byte siZe = size+4; byte Mes[siZe]; byte Checksum = 0; for(byte i=0; i<siZe; i++) { if (i==0) {Mes[i]=size; bitWrite(Mes[i], 7 , 1);} if (i==1) Mes[i] = PCM_address; if (i==2) Mes[i] = DIAG_address; if (i==3) {for (byte t=1; t<size+1; t++ ) { Mes[i]=PCM_Message_TX [command][t]; Checksum+=Mes[i] ; K_LINE_PCM.write (Mes[i]); if (command == INIT) delay (5); else delay (delaybyte_TX); K_LINE_PCM.read(); i++;}} if (i!=siZe-1) Checksum+=Mes[i]; else Mes[i] = Checksum; K_LINE_PCM.write (Mes[i]); if (command == INIT) delay (5); else delay (delaybyte_TX); K_LINE_PCM.read(); } }// end sendMessagePCM #if defined debugPCM or debugGAUGE void printDebugRX (const byte &inbyte) {if (inbyte<=15) Serial.print(F("0")); Serial.print (inbyte, HEX); Serial.print (F(" "));} #endif #ifdef debugPCM void printDebugRX_CSgood(){ if (MessageRx_PCM[n]==0xC1 && MessageRx_PCM[n+1]==0x6B && MessageRx_PCM[n+2]==0x8F) {Serial.println (F(" Initialization OK!!!!")); } else if (MessageRx_PCM[n]==0x58 && MessageRx_PCM[n+1]==0x00) {Serial.println (F(" NO DTC "));} else if (MessageRx_PCM[n]==0x58 && MessageRx_PCM[n+1] >0x00) {Serial.println (F(" DTC is found!"));} else if (MessageRx_PCM[n]==0x54 && MessageRx_PCM[n+1]==0xFF && MessageRx_PCM[n+2]==0x00){Serial.println (F(" DTC CLEARED "));} else if (MessageRx_PCM[n]==0x61 && MessageRx_PCM[n+1]==0x01) {Serial.println (F(" Receive PCM DATAstream"));}} #endif void Menu () { TouchHOME(); if (currentPage == '0') { TouchINF1(); TouchINF2(); TouchCHECK(); } if (currentPage == '1') { TouchINF2(); TouchCHECK(); } if (currentPage == '2') { TouchINF1(); TouchCHECK(); } if (currentPage == '3') { TouchREAD(); TouchERASE(); }} void drawHomeScreen() { reNew = 1; line() ; Watch (); myGLCD.print("/", 115, 7); myGLCD.print("/", 160, 7); myGLCD.setTextColor(RED, BLACK); // цвет линии и текста красный myGLCD.drawLine(295,35,295,248); // линия вертикальная myGLCD.drawLine(145,35,145,178); // линия вертикальная myGLCD.drawLine(80,178,80,247); // линия вертикальная myGLCD.print("L/H", 10, 40); myGLCD.print("L/A", 148, 40); myGLCD.print("L/V", 10, 75); myGLCD.print("L/M", 148, 75); myGLCD.print("D/K", 10, 110); myGLCD.print("D/L", 148, 110); myGLCD.print("V/K", 10, 145); myGLCD.print("V/L", 148, 145); myGLCD.print("PUMP RPM", 82, 180); myGLCD.print("ENGI RPM", 82, 215); myGLCD.print("D/La", 10, 180); myGLCD.print("Motor C", 300, 40); myGLCD.print("OIL C", 300, 75); myGLCD.print("FUEL C", 300, 110); myGLCD.print("INTER C", 300, 145); myGLCD.print("EXTER C", 300, 180); myGLCD.print("INTAIR C", 300, 215); //myGLCD.setTextColor(RED); myGLCD.drawRoundRect (15, 255, 145, 310); myGLCD.print("INF 1", 55, 270); myGLCD.drawRoundRect (175, 255, 305, 310); myGLCD.print("INF 2", 215, 270); myGLCD.drawRoundRect (335, 255, 465, 310); myGLCD.print("CHECK", 365, 270); myGLCD.drawRoundRect (1, 1, 77, 37); myGLCD.print("HOME", 10, 7); myGLCD.print("Km/h", 410, 7); } //------------------------------------------------- void drawscreen_one() { reNew = 1; line() ; Watch (); myGLCD.print("/", 115, 7); myGLCD.print("/", 160, 7); myGLCD.setTextColor(RED, BLACK); // цвет линии и текста красный myGLCD.print("Start of Delivery *CA:", 10, 40); myGLCD.print("Desir inject Start *CA:", 10, 75); myGLCD.print("Actua Inject Start *CA:", 10, 110); myGLCD.print("Desir Inject Quan mg/s:", 10, 145); myGLCD.print("Actu Inject Quant mg/s:", 10, 180); myGLCD.print("MAF mg/s:", 10, 215); myGLCD.print("Humedad %:", 255, 215); //myGLCD.setTextColor(RED); myGLCD.drawRoundRect (175, 255, 305, 310); myGLCD.print("INF 2", 215, 270); myGLCD.drawRoundRect (335, 255, 465, 310); myGLCD.print("CHECK", 365, 270); myGLCD.drawRoundRect (1, 1, 77, 37); myGLCD.print("HOME", 10, 7); myGLCD.print("Km/h", 410, 7); } //------------------------------------------------- void drawscreen_two() { reNew = 1; line() ; Watch (); myGLCD.print("/", 115, 7); myGLCD.print("/", 160, 7); myGLCD.setTextColor(RED, BLACK); // цвет линии и текста красный myGLCD.print("Boost Press Bar:", 10, 40); myGLCD.print("Boost Press Com Bar:", 10, 75); myGLCD.print("EGR command mg/s:", 10, 110); myGLCD.print("EGR Pulse Ratio %:", 10, 145); myGLCD.print("Solenoide Pulse %:", 10, 180); myGLCD.print("Solenoide Boost %:", 10, 215); //myGLCD.setColor(RED); myGLCD.drawRoundRect (15, 255, 145, 310); myGLCD.print("INF 1", 55, 270); myGLCD.drawRoundRect (335, 255, 465, 310); myGLCD.print("CHECK", 365, 270); myGLCD.drawRoundRect (1, 1, 77, 37); myGLCD.print("HOME", 10, 7); myGLCD.print("Km/h", 410, 7); } //---------------------------------------------------------------------------- void drawscreen_three() { reNew = 1; Watch (); myGLCD.print("/", 115, 7); myGLCD.print("/", 160, 7); myGLCD.setTextColor(RED, BLACK); // цвет линии красный myGLCD.drawLine(1,35,479,35); // линия горизонтальная myGLCD.drawLine(1,248,479,248); // линия горизонтальная //myGLCD.setTextColor(RED); myGLCD.drawRoundRect (15, 255, 145, 310); myGLCD.print("ERASE", 55, 270); myGLCD.drawRoundRect (335, 255, 465, 310); myGLCD.print("READ", 365, 270); myGLCD.drawRoundRect (1, 1, 77, 37); myGLCD.print("HOME", 10, 5); } ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////// //кнопки тач . координаты и переходы ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////// void TouchHOME(){ TSPoint p = ts.getPoint(); pinMode(XM, OUTPUT); pinMode(YP, OUTPUT); if (p.z > 10 && p.z < 1000) {if (p.x > 140 && p.x < 320 && p.y > 140 && p.y < 260 && p.z > MINPRESSURE && p.z < MAXPRESSURE) { myGLCD.drawRoundRect (1, 1, 77, 37); currentPage = '0'; request = PID; RequestPeriod = 10; prevRequest = curmillis; // на PCM в этом окне посылается запрос текущих параметров myGLCD.clrScr(); drawHomeScreen(); x = 0; y = 0; p.z = 0;}}} void TouchINF1(){ TSPoint p = ts.getPoint(); pinMode(XM, OUTPUT); pinMode(YP, OUTPUT); if (p.z > 10 && p.z < 1000) { if (p.x > 150 && p.x < 450 && p.y > 770 && p.y < 890 && p.z > MINPRESSURE && p.z < MAXPRESSURE) { myGLCD.drawRoundRect (15, 255, 145, 310); currentPage = '1'; request = PID; RequestPeriod = 10; prevRequest = curmillis; // на PCM в этом окне посылается запрос текущих параметров myGLCD.clrScr(); drawscreen_one(); x = 0; y = 0; p.z = 0;}}} void TouchINF2(){ TSPoint p = ts.getPoint(); pinMode(XM, OUTPUT); pinMode(YP, OUTPUT); if (p.z > 10 && p.z < 1000) { if (p.x > 450 && p.x < 680 && p.y > 770 && p.y < 890 && p.z > MINPRESSURE && p.z < MAXPRESSURE) { myGLCD.drawRoundRect (175, 255, 305, 310); currentPage = '2'; request = PID; RequestPeriod = 600; prevRequest = curmillis; // на PCM в этом окне посылается запрос текущих параметров myGLCD.clrScr(); drawscreen_two(); x = 0; y = 0; p.z = 0;}}} void TouchCHECK(){ TSPoint p = ts.getPoint(); pinMode(XM, OUTPUT); pinMode(YP, OUTPUT); if (p.z > 10 && p.z < 1000) { if (p.x > 690 && p.x < 950 && p.y > 770 && p.y < 890 && p.z > MINPRESSURE && p.z < MAXPRESSURE) { myGLCD.drawRoundRect (335, 255, 465, 310); currentPage = '3'; // request = DTCREAD; RequestPeriod = 10; prevRequest = curmillis; // на PCM в этом окне посылается запрос чтения ошибок myGLCD.clrScr(); drawscreen_three(); x = 0; y = 0; p.z = 0;}}} void TouchREAD(){ TSPoint p = ts.getPoint(); pinMode(XM, OUTPUT); pinMode(YP, OUTPUT); if (p.z > 10 && p.z < 1000) { if (p.x > 690 && p.x < 950 && p.y > 770 && p.y < 890 && p.z > MINPRESSURE && p.z < MAXPRESSURE) { myGLCD.drawRoundRect (335, 255, 465, 310); request = DTCREAD; RequestPeriod = 300; prevRequest = curmillis; // на PCM при нажатии этой кнопки посылается запрос чтения ошибок x = 0; y = 0; p.z = 0;}}} void TouchERASE(){ TSPoint p = ts.getPoint(); pinMode(XM, OUTPUT); pinMode(YP, OUTPUT); if (p.z > 10 && p.z < 1000) { if (p.x > 150 && p.x < 450 && p.y > 770 && p.y < 890 && p.z > MINPRESSURE && p.z < MAXPRESSURE) {myGLCD.drawRoundRect (15, 255, 145, 310); request = DTCERASE; RequestPeriod = 300; prevRequest = curmillis; // на PCM при нажатии этой кнопки посылается запрос удаления ошибок x = 0; y = 0; p.z = 0;}}} //////////////////////////////////////////////////////////////////////////////////////// //прорисовка линий /////////////////////////////////////////////////////////////////////////////////////// void line() { //myGLCD.setTextColor(RED); // цвет линии красный myGLCD.drawLine(1,35,479,35); // линия горизонтальная myGLCD.drawLine(1,73,479,73); // линия горизонтальная myGLCD.drawLine(1,108,479,108); // линия горизонтальная myGLCD.drawLine(1,143,479,143); // линия горизонтальная myGLCD.drawLine(1,178,479,178); // линия горизонтальная myGLCD.drawLine(1,212,479,212); // линия горизонтальная myGLCD.drawLine(1,248,479,248); // линия горизонтальная } void Watch (){ DateTime now = rtc.now(); int minut = now.minute(); int hour = now.hour(); int mon = now.month(); int date = now.day(); int Year = now.year(); static int minut_last; static int hour_last; static int mon_last; static int date_last; static int Year_last; myGLCD.setTextColor(WHITE, BLACK); //белый цвет цифры if (date != date_last || reNew){ myGLCD.printNumI(date, 85, 7, 2, '0'); date_last = date; } if (mon!=mon_last || reNew){myGLCD.printNumI(date, 130, 7, 2, '0'); mon_last = mon; } if (Year!=Year_last || reNew) { myGLCD.printNumI(Year, 175, 7); Year_last = Year; } if (hour!=hour_last || reNew){ myGLCD.printNumI(date, 255, 7, 2, '0'); hour_last = hour; } if (minut!=minut_last || reNew ){ myGLCD.printNumI(date, 300, 7, 2, '0'); minut_last = minut; } }с добавлением скобок все данные отображаются.
812if(date != date_last || reNew){ myGLCD.printNumI(date, 85, 7, 2,'0'); date_last = date; }813814if(mon!=mon_last || reNew){myGLCD.printNumI(date, 130, 7, 2,'0'); mon_last = mon; }815816if(Year!=Year_last || reNew) { myGLCD.printNumI(Year, 175, 7); Year_last = Year; }817818if(hour!=hour_last || reNew){ myGLCD.printNumI(date, 255, 7, 2,'0'); hour_last = hour; }819820if(minut!=minut_last || reNew ){ myGLCD.printNumI(date, 300, 7, 2,'0'); minut_last = minut; }:) от я идиот слепой. Все норм. на счет мест ты говорил что оборот 5 мест а не 4 . так вот заметил например на скорости и на других данных, если ставить четко сколько места то первую цифру не дотирает с краю с лева остается не дотертортость. если поставить на одно метсо большо то все дотирает. проверил на оборотах, по этому одно метсо нужно лишнее. Все ты добил эту библиотеку, теперь дело за Максом, общение с панелью. 816 пронесло потому что была сделана Максом. ЭХ красиво работает.
Ширина пробела в шрифте указана как 7, а цифры около 14 ти - вот и не дотирает один пробел ...
Оптимальнее наверное сделать правильное количество символов и по единичке увеличивать ширину пробела в шрифте и смотреть ...
228{ 0, 0, 0, 7, 0, 1 },// 0x20 ' 'Целый пробел это сразу +7 к ширине - лишнее время. Вдруг хватит +1 или +2
Слова во фразах с пробелом правда то же отъедут на эту же дельту ...
принял ща ковырну. помогло +5 , отлично ща подправлю все. ща буду боротся с цветом линий и рамок кнопок. со словами не проблем есть достаточно места. поборол двоеточие поставил как в моем старом скетче, работет четко if (millis() - prevDvoet > 500) { if (!Dvoet) {myGLCD.print(":", 290, 5);} else {myGLCD.print(" ", 290, 5);} prevDvoet = millis(); Dvoet=!Dvoet;}
вот полностью подправленый скетч. для Макса, для продолжения работы над панелью. Командир тебе ОГРОМНОЕ СПАСИБО, за терпение и труд.
#include <Adafruit_GFX.h> #include <MCUFRIEND_kbv.h> #include <UTFTGLUE.h>//use GLUE class and constructor #include "TouchScreen.h" #include <stdint.h> #include <SPI.h> #include <EEPROM.h> //MCUFRIEND_kbv tft; #include "Fonts/Chosence_Bold16pt7b.h"; #define MINPRESSURE 200 #define MAXPRESSURE 1000 //pin 20 SCL , 21 SDA датчик реального времени #include <Wire.h> #include "RTClib.h" RTC_DS3231 rtc; UTFTGLUE myGLCD(0x1581,A2,A1,A3,A4,A0); //all dummy args const int XP = 6, XM = A2, YP = A1, YM = 7; const int TS_LEFT = 136, TS_RT = 907, TS_TOP = 139, TS_BOT = 942; TouchScreen ts = TouchScreen(XP, YP, XM, YM, 300); uint16_t ID; int x, y; char currentPage; float h; int h_last = 1; float t; int t_last = 1; bool Dvoet = 0; bool reNew = 0; #define BLACK 0x0000 #define WHITE 0xFFFF #define RED 0xF800 #define GREEN 0x07E0 #include <SoftwareSerial.h> #define TX_PCM 13 SoftwareSerial K_LINE_PCM (12, TX_PCM); //RХ,TХ #define PCM_address 0x11 // адрес PCM #define DIAG_address 0xF1 // адрес диагностики #define debugPCM // раскоментировать эту строку для отладки в Serial порту обмена с PCM //#define debugGAUGE // раскоментировать эту строку для отладки в Serial порту обмена co щитком приборов uint32_t curmillis = 0; // снимок текущего времени uint32_t prevRequest = 0; // таймер периодических запосов на PCM uint16_t RequestPeriod = 3500; // периодичность запросов на PCM uint32_t prevRESETheader=0; // таймер сброса сообщения, если данные оборвались посередине сообщения bool RESETheader_timer; // таймер сброса сообщения, если данные оборвались посередине сообщения uint32_t prev_NOanswer=0; // таймер контроля неответов от ЭБУ после подачи запросов bool NOanswer_timer = 0; // таймер контроля неответов от ЭБУ после подачи запросов byte noanswers = 0; // количество подряд неответов от ЭБУ uint32_t timerdelay = 0; // таймер ожидания байт (для успевания появления данных в буфере UART) bool Delay = 0; // таймер ожидания байт (для успевания появления данных в буфере UART) byte waitbyte_RX = 1; // задержка, мс для успевания появления данных в буфере RX // (подрегулировать в зависимости от уровня жизнидеятельности на Марсе) #define TIMER_DELAY Delay = 0; timerdelay = curmillis // включение этого таймера byte delaybyte_TX = 1; // задержка между отправкой байт в запросах, мс byte header = 0; // состояние заголовка byte message_size = 0; // размер тела сообщения byte j = 3; // инкремент byte n = 3; // количество старт байт const byte bufsize = 150; // размер буфера принятого сообщения byte MessageRx_PCM [bufsize] = {0}; // буфер принятого сообщения byte crc =0; // байт контрольной суммы // возможные варианты запросов на ЭБУ: enum REQUEST { INIT, PID, DTCERASE, DTCREAD, PRESENT, }; // текстовки запросов для отладки char* textRequest[] = { "INIT", "PID_2101", "DTC_ERASE", "DTC_READ", "PRESENT", } ; // сами запросы byte PCM_Message_TX[][5] = { {1, 0x81, 0,0,0}, // запрос инициализации {2, 0x21,0x01, 0,0}, // запрос пид 2101 {3, 0x14,0xFF,0x00, 0}, // запрос на стирание ошибок {4, 0x18,0x00,0xFF,0x00 }, // запрос на чтение ошибок {1, 0x3E, 0,0,0}, // запрос присутствия }; byte request = INIT; // переменная, показывающая какой запрос будем делать //-------------------------------------------переменные бортовика float L100M = 0; float L100M_last = 1; //расход на 100 км измеренный за поездку float L100 = 0; float L100_last = 1; //мгновенный расход литров на 100км float LHor = 0; float LHor_last = 1; //мгновенный расход топлива литров в час float L100SR = 0; //расход литров на 100км измеренный раз в интервал kmL float L100SR_TFT = 0; float L100SR_TFT_last = 1; // самый средний из расходов на 100км, он выводится на экран int L100_Eeprom[11]= {10,10,10,10,10,10,10,10,10,10,10}; int FuelZamer[10]= {0}; // массив для измерения уровня (количества) топлива int ZamerNumber = 0; // номер замера уровня (количества) топлива int n_eeprom = 0; // текущий адрес ячейки еепром для записи расхода int MAF = 0; int MAF_last = 1; //26,27 байты Sensor de flujo de aire en masa float BoostPres = 0; float BoostPres_last = 1; //28,29 байты Presión de refuerzo int RPM = 0; int RPM_last = 1; //32,33 байты Velocidad del motor int EGRmg = 0; int EGRmg_last = 1; //34,35 байты Comando EGR (Comando de recirculación de gases de escape) float BoostPresCom = 0; float BoostPresCom_last = 1; //38,39 байты Comando de presión de refuerzo int Speed = 0; int Speed_last = 1; //44,45 байты Velocidad del vehículo float DesaInjQua = 0; float DesaInjQua_last = 1; //50,51 байты Cantidad de inyección deseada float InjQua = 0; float InjQua_last = 1; //52,53 байты Cantidad de la inyección float StaDaliv = 0; float StaDaliv_last = 1; //54,55 байты Inicio de la entrega int PumpRPM = 0; int PumpRPM_last = 1; //56,57 байты Velocidad de la bomba float EGRPul = 0; float EGRPul_last = 1; //62,63 байты Relación de impulsos EGR (recirculación de gases de escape float SolenPul = 0; float SolenPul_last = 1; //64,65 байты Velocidad de solenoide de control de nivel de remolino Relación de impulsos float SolenPre = 0; float SolenPre_last = 1; //70,71 байты Relación de impulsos Presión Electroválvula de presión float DesInj = 0; float DesInj_last = 1; //72,73 байты Inyección deseada Inicio float ActInj = 0; float ActInj_last = 1; //16,17 байты Inicio de la inyección real int TempAir = 0; int TempAir_last = 1; //74,75 байты Temperatura del aire de admisión int Temp = 0; int Temp_last = 1; //14,15 байты Temperatura del refrigerante int TempOil = 0; int TempOil_last = 1; //18,19 байты Temperatura del aceite del motor int TempFuel = 0; int TempFuel_last = 1; //58,59 байты Temperatura del combustible //все что касается топлива float Fuel = 0; //остаток топлива float Fuel2 = 0; float Fuel2_last = 1; //остаток мгновенного топлива байт 16 , датчика в баке int FuelIGN = 0; // количество топлвива в баке на момент включения зажигания int Fuel_last = 0; // для формул bool flagFuelIGN = 0; // флаг записан ли остаток топлива в момент вкл. зажигания float FuelTrip = 0; float FuelTrip_last = 1; // количество литров топлива, израсходованное за один цикл включения зажигания //все что касается километража float kmAge = 0; //пробег, полученный со щитка приборов int kmAgeIGN = 0; //пробег который был в момент включения зажигания int kmAge_last = 0; // для формул bool flagkmAgeIGN = 0; //флаг записан ли пробег в момент вкл. зажигания float kmTrip = 0; float kmTrip_last = 1; //пробег за один цикл включения зажигания int kmL = 10; // интервал, через который будет происходить обновление среднего расхода на 100км int km = 0; // переменная для расчетов int kmeeprom = 10; // интервал, через который будет происходить подсчет среднеарифмитического расхода L100SR_TFT int kmTFT = 0; // переменная для расчетов периодического подсчета среднеарифмитического расхода топлива L100SR_TFT int kmREFUELING = 0; int kmREFUELING_last = 1; // пробег до заправки на остатке топлива unsigned long prevWatch = 0; unsigned long prevDvoet = 0; unsigned long prevData = 0; void setup() { uint16_t ID = myGLCD.readID(); if (ID == 0xD3D3) ID = 0x1581; // write-only shield myGLCD.begin(ID); myGLCD.InitLCD(3); myGLCD.clrScr(); myGLCD.setFont(&Chosence_Bold16pt7b); //myGLCD.fillScreen(WHITE); //myGLCD.setTextColor(WHITE, BLACK); //myGLCD.setBackColor(BLACK); Wire.begin(); rtc.begin(); //загрузка стартовой страницы currentPage = '0'; drawHomeScreen(); //подсчет среднеарифметического усредненного расхода for (int i = 0; i < 11; i++) L100_Eeprom [i]= EEPROM.read(i); for (int i = 0; i < 11; i++) L100SR_TFT = L100SR_TFT + L100_Eeprom [i]; L100SR_TFT = (float)L100SR_TFT/110.0; if (L100SR_TFT<0) L100SR_TFT = 0; if (L100SR_TFT>99) L100SR_TFT = 99; // строка ниже используется для настройки даты и времени часов // раскоментировать, выставить времая и дату, залить в ардуино. в скетче закоментировать // обратно и залить еще раз, иначе каждый раз будет по новой выствлятся это же время и дата // (год, месяц, день, часы, минуты, секунды) //rtc.adjust(DateTime(2019, 7, 2, 10, 48, 0)); #if defined debugPCM or debugGAUGE Serial.begin(115200); #endif K_LINE_PCM.begin(10400); pinMode(TX_PCM, OUTPUT); } void loop() { curmillis = millis(); // снимок текущего времени if (curmillis - prevRequest > RequestPeriod && header == 0 ) { if (request == INIT) fastinit(); // при необходимости делаем переподключение к PCM else {sendMessagePCM(request); // отправляем на PCM текущий запрос if (request == PID) RequestPeriod = 600; if (request == DTCERASE || request == DTCREAD) RequestPeriod = 2500;} prevRequest = curmillis; } receivePCM (); // приём сообщений от PCM if (header == 0) Menu (); if (curmillis - prevWatch > 3000) { Watch (); prevWatch = curmillis;} //if (curmillis - prevDvoet > 500) { if (!Dvoet) {myGLCD.setTextColor(WHITE); } else {myGLCD.setTextColor(BLACK); } myGLCD.print(":", 290, 5); prevDvoet = curmillis; Dvoet=!Dvoet;} if (millis() - prevDvoet > 500) { if (!Dvoet) {myGLCD.print(":", 290, 5);} else {myGLCD.print(" ", 290, 5);} prevDvoet = millis(); Dvoet=!Dvoet;} }// end loop void fastinit() { digitalWrite (TX_PCM, HIGH); // bus idle delay(1500); digitalWrite (TX_PCM, LOW); // first part fastinit (25 ms LOW) delay(25); digitalWrite (TX_PCM, HIGH); // second part fastinit (25 ms HIGH) delay(25); K_LINE_PCM.begin(10400); sendMessagePCM(INIT); // send start communication message } void receivePCM () { if (K_LINE_PCM.available() ){ // первый старт байт if (header == 0 && Delay){TIMER_DELAY ; MessageRx_PCM[0]=K_LINE_PCM.read(); if (MessageRx_PCM[0]!=0xFF && bitRead (MessageRx_PCM[0],7)){header = 1; RESETheader_timer = 1; prevRESETheader = curmillis; #ifdef debugPCM Serial.print (F("Receive PCM: ")); printDebugRX(MessageRx_PCM[0]); #endif } } // второй старт байт if (header == 1 && Delay){TIMER_DELAY ; MessageRx_PCM[1]=K_LINE_PCM.read(); #ifdef debugPCM printDebugRX (MessageRx_PCM[1]); #endif if (MessageRx_PCM[1]==DIAG_address){ header = 2;} else { #ifdef debugPCM Serial.println(F(" PCM Message fail address")); #endif header = 0; RESETheader_timer = 0;}} // третий старт байт if (header == 2 && Delay){ TIMER_DELAY ; MessageRx_PCM[2]=K_LINE_PCM.read(); #ifdef debugPCM printDebugRX (MessageRx_PCM[2]); #endif if (MessageRx_PCM[2]==PCM_address){ message_size = MessageRx_PCM[0]; prevRESETheader = curmillis; if (MessageRx_PCM[0] !=0x80) {header = 4; bitWrite (message_size, 7 , 0);j=3;n=3;} else {header = 3; j=4;n=4;} if (message_size > bufsize) message_size = bufsize; crc = 0;} else {header = 0; #ifdef debugPCM Serial.println(F("PCM Message fail address")); #endif RESETheader_timer = 0;} } // если размер сообщения указан в дополнительном байте (нулевой байт 0x80) читаем этот дополнительный байт: if (header == 3 && Delay){ TIMER_DELAY ; prevRESETheader = curmillis; MessageRx_PCM[3]=K_LINE_PCM.read(); #ifdef debugPCM printDebugRX(MessageRx_PCM[3]); #endif message_size = MessageRx_PCM[3]; if (message_size > bufsize) message_size = bufsize; crc = 0; header = 4; } // пишем тело сообщения if (header == 4 && Delay && j< message_size+n+1) { MessageRx_PCM[j] = K_LINE_PCM.read(); prevRESETheader = curmillis; if (j<message_size+n) crc+= MessageRx_PCM[j]; // подсчёт КС if (j==message_size+n) header = 5; TIMER_DELAY ; #ifdef debugPCM printDebugRX(MessageRx_PCM[j]); #endif j++; } } // сообщение приняли, действуем if (header == 5) {TIMER_DELAY ; #ifdef debugPCM Serial.println(); #endif NOanswer_timer = 0; noanswers = 0; // сбрасываем таймер контроля неответов for(byte i = 0; i<n; i++) crc+=MessageRx_PCM[i]; // прибавляем к контрольной сумме старт байты // если контрольная сумма верна: if ( crc == MessageRx_PCM[message_size+n]) { #ifdef debugPCM Serial.print (F("Received message is OK! Checksum is correct!")); Serial.print (F(" ")); Serial.println (millis()); // Если КС совпала, тут чёнибудь нужное делаем printDebugRX_CSgood(); #endif if (MessageRx_PCM[n]==0xC1 && MessageRx_PCM[n+1]==0x6B && MessageRx_PCM[n+2]==0x8F) { if (currentPage!=3) {request = PID; RequestPeriod = 70;} else request = PRESENT, RequestPeriod = 4000; prevRequest = curmillis; // receive good INIT } else if (MessageRx_PCM[n]==0x58) Troublecodes (); // DTC else if (MessageRx_PCM[n]==0x54 && MessageRx_PCM[n+1]==0xFF && MessageRx_PCM[n+2]==0x00){ request = PRESENT; RequestPeriod = 4000; prevRequest = curmillis;} // DTC are cleared else if (MessageRx_PCM[n]==0x61 && MessageRx_PCM[n+1]==0x01) {dataVars() ; RequestPeriod = 70; prevRequest = curmillis; } // receive DataStream } // если контрольная сумма не совпала: #ifdef debugPCM else Serial.println("CRC fail!!!" ); #endif message_size = 0; header=0; RESETheader_timer = 0; j=3; crc = 0; } // таймер ожидания байт (для успевания появления данных в буфере UART) if (!Delay && curmillis - timerdelay > waitbyte_RX) Delay = 1; // таймер сброса целостности сообщения (если данные оборвались посередине сообщения) if (RESETheader_timer && curmillis - prevRESETheader > 200) { #ifdef debugPCM Serial.println(F("Message fail timeout")); #endif RESETheader_timer = 0; header = 0;} // если нет ответа после запроса: +1 к счетчику неответов. Если накопилось 6 и более: делаем реинит. if (request!=INIT && NOanswer_timer && curmillis - prev_NOanswer > RequestPeriod - RequestPeriod/10) { NOanswer_timer = 0; noanswers++; if (noanswers>=6) { noanswers = 0; request = INIT; RequestPeriod = 3500;} } }// end receivePCM void Troublecodes () { if (MessageRx_PCM[n]==0x58 && MessageRx_PCM[n+1]==0x00){ myGLCD.clrScr(); drawscreen_three(); myGLCD.print("NO DTC", 180, 145); } // при получении сообщения о наличии ошибок DTC разберем сообщение выведем на экран ошибки if (MessageRx_PCM[n]==0x58 && MessageRx_PCM[n+1]>0){ myGLCD.clrScr(); drawscreen_three(); for (int i=0; i<MessageRx_PCM[n+8-7]; i++ ) { int y = i*35; bool nolA=0; bool nolB =0; if (!bitRead(MessageRx_PCM[n+11-7+(i*3)],6) && bitRead(MessageRx_PCM[n+11-7+(i*3)],7)){ myGLCD.setTextColor(GREEN, BLACK); myGLCD.print(" -Passive-", 300, (75+y));} // если DTC пасивныый делаем цвет зеленый if (bitRead(MessageRx_PCM[n+11-7+(i*3)],7) && bitRead(MessageRx_PCM[n+11-7+(i*3)],6)) { myGLCD.setTextColor(RED, BLACK); myGLCD.print(" -Active-", 300, (75+y));} // если DTC активный, делаем цвет красный myGLCD.print("ERROR ", 50, (75+y)); myGLCD.printNumI((i+1), 150, (75+y)); if (!bitRead(MessageRx_PCM[n+9-7+(i*3)],6) && !bitRead(MessageRx_PCM[n+9-7+(i*3)],7)) myGLCD.print(": P", 170, (75+y)); if (bitRead(MessageRx_PCM[n+9-7+(i*3)],6) && !bitRead(MessageRx_PCM[n+9-7+(i*3)],7)) myGLCD.print(": C", 170, (75+y)); if (!bitRead(MessageRx_PCM[n+9-7+(i*3)],6) && bitRead(MessageRx_PCM[n+9-7+(i*3)],7)) myGLCD.print(": B", 170, (75+y)); if (bitRead(MessageRx_PCM[n+9-7+(i*3)],6) && bitRead(MessageRx_PCM[n+9-7+(i*3)],7)) myGLCD.print(": U", 170, (75+y)); if (MessageRx_PCM[n+9-7+(i*3)]==0x00) {myGLCD.print("00", 230, (75+y)); nolA = 1;} if (MessageRx_PCM[n+9-7+(i*3)]<=0x0F&&MessageRx_PCM[n+9-7+(i*3)]!=0) {myGLCD.print("0", 230, (75+y)); nolA = 1;} if (nolA)myGLCD.print(String (MessageRx_PCM[n+9-7+(i*3)],HEX), 246, (75+y)); else myGLCD.print(String (MessageRx_PCM[n+9-7+(i*3)],HEX), 230, (75+y)); if (MessageRx_PCM[n+10-7+(i*3)]==0x00) {myGLCD.print("00", 262, (75+y)); nolB = 1;} if (MessageRx_PCM[n+10-7+(i*3)]<=0x0F&&MessageRx_PCM[n+10-7+(i*3)]!=0) {myGLCD.print("0", 262, (75+y)); nolB = 1;} if (nolB)myGLCD.print(String (MessageRx_PCM[n+10-7+(i*3)]),HEX, 278, (75+y)); else myGLCD.print(String (MessageRx_PCM[n+10-7+(i*3)],HEX), 262, (75+y));}} request = PRESENT; RequestPeriod = 4000; prevRequest = curmillis; } void dataVars() { //Barom = MessageRx_PCM[39]; L100 = (float)LHor*100.0/(float)Speed; LHor = (float)RPM* (float)InjQua*2.00/1000.0*60.00/1000.0/0.85; MAF = ((MessageRx_PCM[n+22]*256)+MessageRx_PCM[n+23])/10; BoostPres = ((MessageRx_PCM[n+24]*256)+MessageRx_PCM[n+25])/1000.0; RPM = (MessageRx_PCM[n+35-7]*256)+MessageRx_PCM[n+36-7]; EGRmg = ((MessageRx_PCM[n+37-7]*256)+MessageRx_PCM[n+38-7])/10.0; BoostPresCom = ((MessageRx_PCM[n+41-7]*256)+MessageRx_PCM[n+42-7])/1000.0; Speed = ((MessageRx_PCM[n+47-7]*256)+MessageRx_PCM[n+48-7])/100; DesaInjQua = ((MessageRx_PCM[n+53-7]*256)+MessageRx_PCM[n+54-7])/100.0; InjQua = ((MessageRx_PCM[n+55-7]*256)+MessageRx_PCM[n+56-7])/100.0; StaDaliv = ((MessageRx_PCM[n+57-7]*256)+MessageRx_PCM[n+58-7])/100.0; PumpRPM = (MessageRx_PCM[n+59-7]*256)+MessageRx_PCM[n+60-7]; EGRPul = ((MessageRx_PCM[n+65-7]*256)+MessageRx_PCM[n+66-7])/100.0; SolenPul = ((MessageRx_PCM[n+67-7]*256)+MessageRx_PCM[n+68-7])/100.0; SolenPre = ((MessageRx_PCM[n+73-7]*256)+MessageRx_PCM[n+74-7])/100.0; DesInj = ((MessageRx_PCM[n+75-7]*3)+(MessageRx_PCM[n+76-7])/100.0)+0.3; ActInj = ((MessageRx_PCM[n+19-7]*3)+(MessageRx_PCM[n+20-7])/100.0)+0.3; //TempAir = ((MessageRx_PCM[n+77-7]*26)-278)+MessageRx_PCM[n+78-7]/10.0; //Temp = ((MessageRx_PCM[n+17-7]*26)-278)+MessageRx_PCM[n+18-7]/10.0; //TempOil = ((MessageRx_PCM[n+21-7]*26)-278)+MessageRx_PCM[n+22-7]/10.0; //TempFuel = ((MessageRx_PCM[n+61-7]*26)-278)+MessageRx_PCM[n+62-7]/10.0; //ниже идут расчетные формулы более точные чем те что закоментированы выше int A = 0; if (MessageRx_PCM[n+77-7]<=0x0A) A = 277; if (MessageRx_PCM[n+77-7]==0x0B || MessageRx_PCM[n+77-7]==0x0C) A = 278; if (MessageRx_PCM[n+77-7]>=0x0D) A = 279; double B = MessageRx_PCM[n+78-7]/10.0; double cel , drob ; drob = modf(B, &cel); if (drob>0.6) cel++; TempAir = ((MessageRx_PCM[n+77-7]*26)-A)+cel; if (MessageRx_PCM[n+17-7]<=0x0A) A = 277; if (MessageRx_PCM[n+17-7]==0x0B || MessageRx_PCM[n+17-7]==0x0C) A = 278; if (MessageRx_PCM[n+17-7]>=0x0D) A = 279; B = MessageRx_PCM[n+18-7]/10.0; drob = modf(B, &cel); if (drob>0.6) cel++; Temp = ((MessageRx_PCM[n+17-7]*26)-A)+cel; if (MessageRx_PCM[n+21-7]<=0x0A) A = 277; if (MessageRx_PCM[n+21-7]==0x0B || MessageRx_PCM[n+21-7]==0x0C) A = 278; if (MessageRx_PCM[n+21-7]>=0x0D) A = 279; B = MessageRx_PCM[n+22-7]/10.0; drob = modf(B, &cel); if (drob>0.6) cel++; TempOil = ((MessageRx_PCM[n+21-7]*26)-A)+cel; if (MessageRx_PCM[n+61-7]<=0x0A) A = 277; if (MessageRx_PCM[n+61-7]==0x0B || MessageRx_PCM[n+61-7]==0x0C) A = 278; if (MessageRx_PCM[n+61-7]>=0x0D) A = 279; B = MessageRx_PCM[n+62-7]/10.0; drob = modf(B, &cel); if (drob>0.6) cel++; TempFuel = ((MessageRx_PCM[n+61-7]*26)-A)+cel; //---------------------------------------------------------- //страниц HOME //---------------------------------------------------------- //myGLCD.setBackColor(RED); myGLCD.setTextColor(WHITE, BLACK); //myGLCD.setBackColor(RED); if ((Speed != Speed_last) || reNew) {myGLCD.printNumI(Speed, 360, 7, 3); Speed_last=Speed;} if (currentPage == '0') { if ((LHor != LHor_last) || reNew) {myGLCD.printNumF(LHor, 1, 75, 40, '.',4); LHor_last=LHor;} if ((L100 != L100_last) || reNew) {myGLCD.printNumF(L100, 1, 225, 40,'.',4 ); L100_last=L100;} if ((L100M != L100M_last) || reNew) {myGLCD.printNumF(L100M, 1, 75, 75,'.',4 ); L100M_last=L100M;} if ((L100SR_TFT != L100SR_TFT_last) || reNew) {myGLCD.printNumF(L100SR_TFT, 1, 225, 75,'.',4 ); L100SR_TFT_last=L100SR_TFT;} if ((kmREFUELING != kmREFUELING_last) || reNew) {myGLCD.printNumI(kmREFUELING, 90, 110,3 ); kmREFUELING_last=kmREFUELING;} //if (Fuel<53) if ((Fuel != Fuel_last) || reNew) {myGLCD.printNumF(Fuel, 1, 225, 110,'.',4); Fuel_last=Fuel;} //else myGLCD.print("MAX", 210, 110); if ((kmTrip != kmTrip_last) || reNew) {myGLCD.printNumF(kmTrip, 1, 60, 145,'.',5); kmTrip_last=kmTrip;} if ((FuelTrip != FuelTrip_last) || reNew) {myGLCD.printNumF(FuelTrip, 1, 210, 145,'.',5); FuelTrip_last=FuelTrip;} if ((PumpRPM != PumpRPM_last) || reNew) {myGLCD.printNumI(PumpRPM, 230, 180,4); PumpRPM_last=PumpRPM;} if ((RPM != RPM_last) || reNew) {myGLCD.printNumI(RPM, 230, 215,4); RPM_last=RPM;} if ((Fuel2 != Fuel2_last) || reNew) {myGLCD.printNumF(Fuel2, 1, 10, 215,'.',4); Fuel2_last=Fuel2;} if ((Temp != Temp_last) || reNew) {myGLCD.printNumI(Temp, 415, 40, 3); Temp_last=Temp;} if ((TempOil != TempOil_last) || reNew) {myGLCD.printNumI(TempOil, 415, 75, 3); TempOil_last=TempOil;} if ((TempFuel != TempFuel_last) || reNew) {myGLCD.printNumI(TempFuel, 415, 110,3); TempFuel_last=TempFuel;} //myGLCD.printNumI(sensors.getTempCByIndex(0), 415, 145 , 3); if ((t != t_last) || reNew) {myGLCD.printNumI(t, 415, 180, 3); t_last=t;} if ((TempAir != TempAir_last) || reNew) {myGLCD.printNumI(TempAir, 415, 215, 3); TempAir_last=TempAir;} reNew = 0; } //---------------------------------------------------------- //страниц INF1 //---------------------------------------------------------- if (currentPage == '1') { if ((StaDaliv != StaDaliv_last) || reNew) {myGLCD.printNumF(StaDaliv,1, 385, 40,'.', 4); StaDaliv_last=StaDaliv;} if ((DesInj != DesInj_last) || reNew) {myGLCD.printNumF(DesInj,1, 385, 75, '.', 4); DesInj_last=DesInj;} if ((ActInj != ActInj_last) || reNew) {myGLCD.printNumF(ActInj,1, 385, 110,'.', 4); ActInj_last=ActInj;} if ((DesaInjQua != DesaInjQua_last) || reNew) {myGLCD.printNumF(DesaInjQua,1, 385, 145,'.', 4);DesaInjQua_last=DesaInjQua;} if ((InjQua != InjQua_last) || reNew) {myGLCD.printNumF(InjQua,1, 385, 180,'.', 4); InjQua_last=InjQua;} if ((MAF != MAF_last) || reNew) {myGLCD.printNumI(MAF, 170, 215, 4); MAF_last=MAF;} if ((h != h_last) || reNew) {myGLCD.printNumF(h, 1, 430, 215, 3); h_last=h;} reNew = 0; } //---------------------------------------------------------- //страниц INF2 //---------------------------------------------------------- if (currentPage == '2') { if ((BoostPres != BoostPres_last) || reNew) {myGLCD.printNumF(BoostPres,1, 400, 40,'.', 4); BoostPres_last=BoostPres;} if ((BoostPresCom != BoostPresCom_last) || reNew) {myGLCD.printNumF(BoostPresCom,1, 400, 75,'.', 4); BoostPresCom_last=BoostPresCom;} if ((EGRmg != EGRmg_last) || reNew) {myGLCD.printNumI(EGRmg, 400, 110, 4); EGRmg_last=EGRmg;} if ((EGRPul != EGRPul_last) || reNew) {myGLCD.printNumF(EGRPul,1, 400, 145,'.', 4); EGRPul_last=EGRPul;} if ((SolenPul != SolenPul_last) || reNew) {myGLCD.printNumF(SolenPul, 1, 400, 180,'.', 4); SolenPul_last=SolenPul;} if ((SolenPre != SolenPre_last) || reNew) {myGLCD.printNumF(SolenPre, 0, 400, 215,'.', 4); SolenPre_last=SolenPre;} reNew = 0; } //reNew = 0; } void sendMessagePCM(const byte &command) { #ifdef debugPCM Serial.print (F("Send request ")); Serial.print (textRequest[command]); Serial.print (F(" to PCM ")); Serial.println (millis()); #endif if (command != INIT) {NOanswer_timer = 1; prev_NOanswer = curmillis;} //т.к. сейчас будем делать запрос, то запускаем таймер контроля неответов byte size = PCM_Message_TX[command][0]; const byte siZe = size+4; byte Mes[siZe]; byte Checksum = 0; for(byte i=0; i<siZe; i++) { if (i==0) {Mes[i]=size; bitWrite(Mes[i], 7 , 1);} if (i==1) Mes[i] = PCM_address; if (i==2) Mes[i] = DIAG_address; if (i==3) {for (byte t=1; t<size+1; t++ ) { Mes[i]=PCM_Message_TX [command][t]; Checksum+=Mes[i] ; K_LINE_PCM.write (Mes[i]); if (command == INIT) delay (5); else delay (delaybyte_TX); K_LINE_PCM.read(); i++;}} if (i!=siZe-1) Checksum+=Mes[i]; else Mes[i] = Checksum; K_LINE_PCM.write (Mes[i]); if (command == INIT) delay (5); else delay (delaybyte_TX); K_LINE_PCM.read(); } }// end sendMessagePCM #if defined debugPCM or debugGAUGE void printDebugRX (const byte &inbyte) {if (inbyte<=15) Serial.print(F("0")); Serial.print (inbyte, HEX); Serial.print (F(" "));} #endif #ifdef debugPCM void printDebugRX_CSgood(){ if (MessageRx_PCM[n]==0xC1 && MessageRx_PCM[n+1]==0x6B && MessageRx_PCM[n+2]==0x8F) {Serial.println (F(" Initialization OK!!!!")); } else if (MessageRx_PCM[n]==0x58 && MessageRx_PCM[n+1]==0x00) {Serial.println (F(" NO DTC "));} else if (MessageRx_PCM[n]==0x58 && MessageRx_PCM[n+1] >0x00) {Serial.println (F(" DTC is found!"));} else if (MessageRx_PCM[n]==0x54 && MessageRx_PCM[n+1]==0xFF && MessageRx_PCM[n+2]==0x00){Serial.println (F(" DTC CLEARED "));} else if (MessageRx_PCM[n]==0x61 && MessageRx_PCM[n+1]==0x01) {Serial.println (F(" Receive PCM DATAstream"));}} #endif void Menu () { TouchHOME(); if (currentPage == '0') { TouchINF1(); TouchINF2(); TouchCHECK(); } if (currentPage == '1') { TouchINF2(); TouchCHECK(); } if (currentPage == '2') { TouchINF1(); TouchCHECK(); } if (currentPage == '3') { TouchREAD(); TouchERASE(); }} void drawHomeScreen() { reNew = 1; line() ; Watch (); //myGLCD.print(":", 290, 5); myGLCD.print("/", 115, 7); myGLCD.print("/", 160, 7); myGLCD.setTextColor(RED, BLACK); // цвет линии и текста красный myGLCD.drawLine(295,35,295,248); // линия вертикальная myGLCD.drawLine(145,35,145,178); // линия вертикальная myGLCD.drawLine(80,178,80,247); // линия вертикальная myGLCD.print("L/H", 10, 40); myGLCD.print("L/A", 148, 40); myGLCD.print("L/V", 10, 75); myGLCD.print("L/M", 148, 75); myGLCD.print("D/K", 10, 110); myGLCD.print("D/L", 148, 110); myGLCD.print("V/K", 10, 145); myGLCD.print("V/L", 148, 145); myGLCD.print("PUMP RPM", 82, 180); myGLCD.print("ENGI RPM", 82, 215); myGLCD.print("D/L/A", 10, 180); myGLCD.print("Motor C", 300, 40); myGLCD.print("OIL C", 300, 75); myGLCD.print("FUEL C", 300, 110); myGLCD.print("INTER C", 300, 145); myGLCD.print("EXTER C", 300, 180); myGLCD.print("INTAIR C", 300, 215); //myGLCD.setTextColor(RED); myGLCD.drawRoundRect (15, 255, 145, 310); myGLCD.print("INF 1", 55, 270); myGLCD.drawRoundRect (175, 255, 305, 310); myGLCD.print("INF 2", 215, 270); myGLCD.drawRoundRect (335, 255, 465, 310); myGLCD.print("CHECK", 365, 270); myGLCD.drawRoundRect (1, 1, 77, 37); myGLCD.print("HOME", 10, 7); myGLCD.print("Km/h", 410, 7); } //------------------------------------------------- void drawscreen_one() { reNew = 1; line() ; Watch (); //myGLCD.print(":", 290, 5); myGLCD.print("/", 115, 7); myGLCD.print("/", 160, 7); myGLCD.setTextColor(RED, BLACK); // цвет линии и текста красный myGLCD.print("Start of Delivery *CA:", 10, 40); myGLCD.print("Desir inject Start *CA:", 10, 75); myGLCD.print("Actua Inject Start *CA:", 10, 110); myGLCD.print("Desir Inject Quan mg/s:", 10, 145); myGLCD.print("Actu Inject Quant mg/s:", 10, 180); myGLCD.print("MAF mg/s:", 10, 215); myGLCD.print("Humedad %:", 255, 215); //myGLCD.setTextColor(RED); myGLCD.drawRoundRect (175, 255, 305, 310); myGLCD.print("INF 2", 215, 270); myGLCD.drawRoundRect (335, 255, 465, 310); myGLCD.print("CHECK", 365, 270); myGLCD.drawRoundRect (1, 1, 77, 37); myGLCD.print("HOME", 10, 7); myGLCD.print("Km/h", 410, 7); } //------------------------------------------------- void drawscreen_two() { reNew = 1; line() ; Watch (); //myGLCD.print(":", 290, 5); myGLCD.print("/", 115, 7); myGLCD.print("/", 160, 7); myGLCD.setTextColor(RED, BLACK); // цвет линии и текста красный myGLCD.print("Boost Press Bar:", 10, 40); myGLCD.print("Boost Press Com Bar:", 10, 75); myGLCD.print("EGR command mg/s:", 10, 110); myGLCD.print("EGR Pulse Ratio %:", 10, 145); myGLCD.print("Solenoide Pulse %:", 10, 180); myGLCD.print("Solenoide Boost %:", 10, 215); //myGLCD.setColor(RED); myGLCD.drawRoundRect (15, 255, 145, 310); myGLCD.print("INF 1", 55, 270); myGLCD.drawRoundRect (335, 255, 465, 310); myGLCD.print("CHECK", 365, 270); myGLCD.drawRoundRect (1, 1, 77, 37); myGLCD.print("HOME", 10, 7); myGLCD.print("Km/h", 410, 7); } //---------------------------------------------------------------------------- void drawscreen_three() { reNew = 1; Watch (); //myGLCD.print(":", 290, 5); myGLCD.print("/", 115, 7); myGLCD.print("/", 160, 7); myGLCD.setTextColor(RED, BLACK); // цвет линии красный myGLCD.drawLine(1,35,479,35); // линия горизонтальная myGLCD.drawLine(1,248,479,248); // линия горизонтальная //myGLCD.setTextColor(RED); myGLCD.drawRoundRect (15, 255, 145, 310); myGLCD.print("ERASE", 55, 270); myGLCD.drawRoundRect (335, 255, 465, 310); myGLCD.print("READ", 365, 270); myGLCD.drawRoundRect (1, 1, 77, 37); myGLCD.print("HOME", 10, 5); } ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////// //кнопки тач . координаты и переходы ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////// void TouchHOME(){ TSPoint p = ts.getPoint(); pinMode(XM, OUTPUT); pinMode(YP, OUTPUT); if (p.z > 10 && p.z < 1000) {if (p.x > 140 && p.x < 320 && p.y > 140 && p.y < 260 && p.z > MINPRESSURE && p.z < MAXPRESSURE) { myGLCD.drawRoundRect (1, 1, 77, 37); currentPage = '0'; request = PID; RequestPeriod = 10; prevRequest = curmillis; // на PCM в этом окне посылается запрос текущих параметров myGLCD.clrScr(); drawHomeScreen(); x = 0; y = 0; p.z = 0;}}} void TouchINF1(){ TSPoint p = ts.getPoint(); pinMode(XM, OUTPUT); pinMode(YP, OUTPUT); if (p.z > 10 && p.z < 1000) { if (p.x > 150 && p.x < 450 && p.y > 770 && p.y < 890 && p.z > MINPRESSURE && p.z < MAXPRESSURE) { myGLCD.drawRoundRect (15, 255, 145, 310); currentPage = '1'; request = PID; RequestPeriod = 10; prevRequest = curmillis; // на PCM в этом окне посылается запрос текущих параметров myGLCD.clrScr(); drawscreen_one(); x = 0; y = 0; p.z = 0;}}} void TouchINF2(){ TSPoint p = ts.getPoint(); pinMode(XM, OUTPUT); pinMode(YP, OUTPUT); if (p.z > 10 && p.z < 1000) { if (p.x > 450 && p.x < 680 && p.y > 770 && p.y < 890 && p.z > MINPRESSURE && p.z < MAXPRESSURE) { myGLCD.drawRoundRect (175, 255, 305, 310); currentPage = '2'; request = PID; RequestPeriod = 600; prevRequest = curmillis; // на PCM в этом окне посылается запрос текущих параметров myGLCD.clrScr(); drawscreen_two(); x = 0; y = 0; p.z = 0;}}} void TouchCHECK(){ TSPoint p = ts.getPoint(); pinMode(XM, OUTPUT); pinMode(YP, OUTPUT); if (p.z > 10 && p.z < 1000) { if (p.x > 690 && p.x < 950 && p.y > 770 && p.y < 890 && p.z > MINPRESSURE && p.z < MAXPRESSURE) { myGLCD.drawRoundRect (335, 255, 465, 310); currentPage = '3'; // request = DTCREAD; RequestPeriod = 10; prevRequest = curmillis; // на PCM в этом окне посылается запрос чтения ошибок myGLCD.clrScr(); drawscreen_three(); x = 0; y = 0; p.z = 0;}}} void TouchREAD(){ TSPoint p = ts.getPoint(); pinMode(XM, OUTPUT); pinMode(YP, OUTPUT); if (p.z > 10 && p.z < 1000) { if (p.x > 690 && p.x < 950 && p.y > 770 && p.y < 890 && p.z > MINPRESSURE && p.z < MAXPRESSURE) { myGLCD.drawRoundRect (335, 255, 465, 310); request = DTCREAD; RequestPeriod = 300; prevRequest = curmillis; // на PCM при нажатии этой кнопки посылается запрос чтения ошибок x = 0; y = 0; p.z = 0;}}} void TouchERASE(){ TSPoint p = ts.getPoint(); pinMode(XM, OUTPUT); pinMode(YP, OUTPUT); if (p.z > 10 && p.z < 1000) { if (p.x > 150 && p.x < 450 && p.y > 770 && p.y < 890 && p.z > MINPRESSURE && p.z < MAXPRESSURE) {myGLCD.drawRoundRect (15, 255, 145, 310); request = DTCERASE; RequestPeriod = 300; prevRequest = curmillis; // на PCM при нажатии этой кнопки посылается запрос удаления ошибок myGLCD.clrScr(); drawscreen_three(); myGLCD.print("DTC BORRADO", 180, 145); x = 0; y = 0; p.z = 0;}}} //////////////////////////////////////////////////////////////////////////////////////// //прорисовка линий /////////////////////////////////////////////////////////////////////////////////////// void line() { //myGLCD.setTextColor(RED); // цвет линии красный myGLCD.drawLine(1,35,479,35); // линия горизонтальная myGLCD.drawLine(1,73,479,73); // линия горизонтальная myGLCD.drawLine(1,108,479,108); // линия горизонтальная myGLCD.drawLine(1,143,479,143); // линия горизонтальная myGLCD.drawLine(1,178,479,178); // линия горизонтальная myGLCD.drawLine(1,212,479,212); // линия горизонтальная myGLCD.drawLine(1,248,479,248); // линия горизонтальная } void Watch (){ DateTime now = rtc.now(); int minut = now.minute(); int hour = now.hour(); int mon = now.month(); int date = now.day(); int Year = now.year(); static int minut_last; static int hour_last; static int mon_last; static int date_last; static int Year_last; myGLCD.setTextColor(WHITE, BLACK); //белый цвет цифры if (date != date_last || reNew){ myGLCD.printNumI(date, 85, 7, 2, '0'); date_last = date; } if (mon!=mon_last || reNew){myGLCD.printNumI(mon, 130, 7, 2, '0'); mon_last = mon; } if (Year!=Year_last || reNew) { myGLCD.printNumI(Year, 175, 7); Year_last = Year; } if (hour!=hour_last || reNew){ myGLCD.printNumI(hour, 255, 7, 2, '0'); hour_last = hour; } if (minut!=minut_last || reNew ){ myGLCD.printNumI(minut, 300, 7, 2, '0'); minut_last = minut; } }трудно будет делать какие то остальные вещи, когда скетч на секунду тормозится. Ну ладно , приеду, чё нить попробуем сделать
дык а старый скетч раз в секунду тоже обновлялся. а этот даже чуточку быстрее. Макс сделай все что сможешь, а там уже как будет так будет. И СПАСИБО зараннее
Привет, MaksVV! Наконец-то дошли руки сделать твое задание из поста №1399:
"подключаешь эксплоер к машине. Параллельно цепляешь сниффер, (та же к-лайн ардуина только со скетчем сниффера), он много раз тут обсуждался ищи. Когда будет сниф, можно будет о чём то говорить. Расшаривается быстрее, без всяких документов. Очень часто описание протокола не соответствует дейтсвительности. "
В программе Шевроле-Эксплорер установил только параметр Напряжение бортсети, получилось вот так:
А тут установил только параметр Температура ОЖ:
Лог сделан твоим сниффером из поста 1197. Напомню что автомобиль Нексия N-150, 16-ти клапанный, ЭБУ-Сириус-42. При запросах Пидов ЭБУ не выдавал MAF, напряжение бортсети, время впрыска и др.
Подскажи, пож-та, как перелопатить всю эту массу байтов и найти там хоть что-то полезное!?
Коллеги,
помогите сориентироваться, пожалуйста.
У меня Корса Ц 2005 года 12ХЕ
Настроил работу K-line. соединяется через Ардуино Уно. Загрузил ваш скетч из #41 http://arduino.ru/forum/proekty/bortovoi-kompyuter-dlya-opel-zafira#comment-290979, который идет в самом начале темы. Выдает, что подключение проходит, а температуру не видит корректно. Попробовал подключить OP COM к машине и посмотреть что идет через Device Monitor. Я подозреваю, что в моей машине адрес обращения к температуре другой или я не прав? в чем моя ошибка? Почему не приходят данные о температуре? На картинке я пытался подключиться по OP COM к мотору и снять даннные в разделе Measurement на второй странице, закрыв все запросы кроме запроса на температуру мотора. Послее подмены вашего запроса в скетче на свой 82 11 F1 21 01 A6 показания какие то приходят, но я не те, что выдает OP COM
Мне не совсем ясно как мне выудить из того что я имею запрос на температуру? помогите, пожалуйста, объясните.
MaksVV, я думаю что сложно будет разобраться в том потоке данных, что мне выдал Шевроле Эксплорер. Попробую поснифить данные от Оливии
Макс в отпуске, будет после середины августа.
Ок, видимо придется разбираться самому..
Abt, подключиться к автомобилю опкомом. Параллельно на к линию подключить сниффер на связке ардуино/клайн. Скетч сниффера есть #1147. Внимательно с номерами пинов софт сериала и клайн на ардуино. Результат сюда
Lev2606, приеду с отпуска сниф разберу.