INTRE 3,5" 480 x 320 TFT LCD HX8357D SPI Library

2015-03-19T01:30:11+01:00

Chciałby zaprezentować wstępną bibliotekę po "SPI" do wyświetlacza 3,5" 480 x 320 TFT LCD opartego o sterownik HX8357D firmy Adafruit https://www.adafruit.com/product/2050 napisaną przeze mnie na podstawie oryginalnej biblioteki od firmy Adafruit dla Arduino oraz doświadczeń zdobytych podczas nauk Mirka dotyczących wyświetlaczy OLED oraz tzw. Green Booka.

Myślę że na początek film z jej pracy na wyświetlaczu, na żywo wygląda to zdecydowanie lepiej niestety kamera, którą posiadam nie oddaje "ładności" świecenia jego jednakże bardziej mam na celu pokazanie pracy i możliwości funkcji jakie posiada biblioteka.

iframe

A teraz kod Myślę że za specjalnie nie ma co go komentować osobno, albo raczej mi się tak wydaję bo starałem się napisać ją czytelnie i w miarę zrozumiale dodając stosowne komentarze.
Nie będę może zupełnie całego programu testowego publikować na stronie ale dodam go całego spakowanego na końcu tematu jako załącznik do obejrzenia i ewentualnych własnych testów jak ktoś w/w wyświetlacz nabędzie.

main.c
[syntax=c]/*
* main.c
*
* Created on: 17-03-2015
* Author: Intre
*
* Biblioteka i program testowy dla wyświetlacza: Adafruit 3,5" 480 x 320 TFT LCD Breakout Board
* https://www.adafruit.com/product/2050
*
* Napisana na podstawie oryginalnej biblioteki do w/w wyświetlacza Adafruit
* i doświadczeń nabytych podczas nauki pisania biblioteki do wyświetlacza OLED:
* http://mirekk36.blogspot.com/2014/08/wyswietlacz-oled-c-library-part-01a.html
* https://www.youtube.com/watch?v=IDhnhCp61Ao
* oraz książki JĘZYK C PASJA PROGRAMOWANIA MIKROKONTROLERÓW 8-BITOWYCH
* https://www.sklep.atnel.pl/pl/p/Jezyk-C-Pasja-programowania-mikrokontrolerow-8-bitowych-Wydanie-II-Ksiazka-DVD/104
* thx mirekk36 :)
*
* licencja darmowa i jeśli ktoś chce z niej korzystać to proszę zamieszczać w/w preambułe oraz Copyright (c) 2013 Adafruit Industries.
*
* sterownik: HX8357D
* komunikacja: SPI
*
*/

#include
#include
#include
#include

#include "INTRE_HX8357D/hx8357D.h"
#include "BITMAPS/bitmaps.h"
#include "TIMERS/timers.h"
#include "INTRE_DEMO/intre_demo.h"

int main(void) {

//inicjalizacja Timer 2
timer2_init();

//ustawienie wyświetlanego czasu
set_higrometer_time (17,59);

//inicjalizacja wyświetlacza, rotacja 0-3
hx8357d_init (3);

//prezentacja różnych możliwości biblioteki na TFT LCD
intre_HX8357D_library_demo ();

//inicjalizacja dema Higrometru
hx8357d_cls(black);
higrometer_colors (0);
higrometer_scheme ();

//włączenie przerwań
sei();

while(1) {

intre_higrometer_demo ();
}

}[/syntax]

hx8357D.h
[syntax=c]/*
* hx8357D.h
*
* Created on: 16-03-2015
* Author: Intre
*/

#ifndef HX8357D_H_
#define HX8357D_H_

// ### definicje stałych preprocesora ###

// hardware SPI
#define CLK PB7
#define MISO PB6
#define MOSI PB5
#define CS (1<#define DC (1<
//definicje portów pinów
#define CLK_PORT PORTB
#define CLK_DDRDDRB

#define CS_PORT PORTB
#define CS_DDRDDRB

#define DC_PORT PORTB
#define DC_DDRDDRB

// zmiana stanów pinów LOW/HI
#define CLK_LOWCLK_PORT &= ~CLK
#define CLK_HI CLK_PORT |= CLK

#define CS_LOW CS_PORT &= ~CS
#define CS_HI CS_PORT |= CS

#define DC_LOW DC_PORT &= ~DC
#define DC_HI DC_PORT |= DC

// komendy dla sterownika HX8357D
#define HX8357D 0xD
#define HX8357B 0xB

#define HX8357_TFTWIDTH 320
#define HX8357_TFTHEIGHT 480

#define HX8357_NOP 0x00
#define HX8357_SWRESET 0x01
#define HX8357_RDDID 0x04
#define HX8357_RDDST 0x09

#define HX8357_RDPOWMODE 0x0A
#define HX8357_RDMADCTL 0x0B
#define HX8357_RDCOLMOD 0x0C
#define HX8357_RDDIM 0x0D
#define HX8357_RDDSDR 0x0F

#define HX8357_SLPIN 0x10
#define HX8357_SLPOUT 0x11
#define HX8357B_PTLON 0x12
#define HX8357B_NORON 0x13

#define HX8357_INVOFF 0x20
#define HX8357_INVON 0x21
#define HX8357_DISPOFF 0x28
#define HX8357_DISPON 0x29

#define HX8357_CASET 0x2A
#define HX8357_PASET 0x2B
#define HX8357_RAMWR 0x2C
#define HX8357_RAMRD 0x2E

#define HX8357B_PTLAR 0x30
#define HX8357_TEON 0x35
#define HX8357_TEARLINE 0x44
#define HX8357_MADCTL 0x36
#define HX8357_COLMOD 0x3A

#define HX8357_SETOSC 0xB0
#define HX8357_SETPWR1 0xB1
#define HX8357B_SETDISPLAY 0xB2
#define HX8357_SETRGB 0xB3
#define HX8357D_SETCOM 0xB6

#define HX8357B_SETDISPMODE 0xB4
#define HX8357D_SETCYC 0xB4
#define HX8357B_SETOTP 0xB7
#define HX8357D_SETC 0xB9

#define HX8357B_SET_PANEL_DRIVING 0xC0
#define HX8357D_SETSTBA 0xC0
#define HX8357B_SETDGC 0xC1
#define HX8357B_SETID 0xC3
#define HX8357B_SETDDB 0xC4
#define HX8357B_SETDISPLAYFRAME 0xC5
#define HX8357B_GAMMASET 0xC8
#define HX8357B_SETCABC 0xC9
#define HX8357_SETPANEL 0xCC

#define HX8357B_SETPOWER 0xD0
#define HX8357B_SETVCOM 0xD1
#define HX8357B_SETPWRNORMAL 0xD2

#define HX8357B_RDID1 0xDA
#define HX8357B_RDID2 0xDB
#define HX8357B_RDID3 0xDC
#define HX8357B_RDID4 0xDD

#define HX8357D_SETGAMMA 0xE0

#define HX8357B_SETGAMMA 0xC8
#define HX8357B_SETPANELRELATED 0xE9

//kolory
#define black 0x0000
#define navy 0x000F
#define dark_green 0x03E0
#define dark_cyan 0x03EF
#define maroon 0x7800
#define purple 0x780F
#define olive 0x7BE0
#define light_grey 0xC618
#define dark_grey 0x7BEF
#define blue 0x001F
#define green 0x07E0
#define cyan 0x07FF
#define red 0xF800
#define magenta 0xF81F
#define yellow 0xFFE0
#define white 0xFFFF
#define orange 0xFD20
#define green_yellow 0xAFE5
#define brown 0x79E0

//definicje kierunków
#define MADCTL_MY 0x80
#define MADCTL_MX 0x40
#define MADCTL_MV 0x20
#define MADCTL_ML 0x10
#define MADCTL_RGB 0x00
#define MADCTL_BGR 0x08
#define MADCTL_MH 0x04

//definicje pomocnicze
#define swap(a, b) { int16_t t = a; a = b; b = t; }

//deklaracje zmiennych
uint16_t _width, _height;
extern const uint8_t font[];
extern int crsor_x, cursor_y;

// ### deklaracje funkcji ###

//funkcje sprzętowe
void hx8357d_init_spi(void); //
void spi_send( uint8_t bajt ); //
void hx8357d_command( uint8_t cmd );//
void hx8357d_data( uint8_t dat );//
void hx8357d_init (uint8_t rot);//
void hx8357d_setAddrWindow(uint16_t x0, uint16_t y0, uint16_t x1, uint16_t y1);
void hx8357d_cls(uint16_t color); //całyekran kolor
void hx8357d_setRotation(uint8_t rotation);
uint16_t hx8357d_color565(uint8_t r, uint8_t g, uint8_t b);
void hx8357d_pushColor(uint16_t color);

//funkcje graficzne
void hx8357d_drawPixel(int16_t x, int16_t y, uint16_t color); //podstawowa funkcja zapalająca pixel
void hx8357d_drawFastVLine(int16_t x, int16_t y, int16_t h, uint16_t color); //linia pion
void hx8357d_drawFastHLine(int16_t x, int16_t y, int16_t w, uint16_t color); //linia poziom
void hx8357d_drawLine( int x0, int y0, int x1, int y1, uint16_t color); //linia
void hx8357d_drawCircle(int16_t x0, int16_t y0, int16_t r, uint16_t color); //kółko puste
void hx8357d_drawCircleHelper( int16_t x0, int16_t y0, int16_t r, uint8_t cornername, uint16_t color);
void hx8357d_fillCircleHelper(int16_t x0, int16_t y0, int16_t r, uint8_t cornername, int16_t delta, uint16_t color);
void hx8357d_fillCircle(int16_t x0, int16_t y0, int16_t r, uint16_t color); // kółko wypełnione
void hx8357d_drawRect(int16_t x, int16_t y, int16_t w, int16_t h, uint16_t color); // prostokąt pusty
void hx8357d_fillRect(int16_t x, int16_t y, int16_t w, int16_t h, uint16_t color); //prostokąt wypełniony
void hx8357d_drawRoundRect(int16_t x, int16_t y, int16_t w, int16_t h, int16_t r, uint16_t color); // prostokąt zaokrąglony pusty
void hx8357d_fillRoundRect(int16_t x, int16_t y, int16_t w, int16_t h, int16_t r, uint16_t color); // prostokąt zaokrąglony pełny
void hx8357d_drawTriangle(int16_t x0, int16_t y0, int16_t x1, int16_t y1, int16_t x2, int16_t y2, uint16_t color); // trójkąt pusty
void hx8357d_fillTriangle ( int16_t x0, int16_t y0, int16_t x1, int16_t y1, int16_t x2, int16_t y2, uint16_t color); //trójkąt wypełniony

// % bar
void hx8357d_ProgressBar( uint16_t x_begin, uint16_t y, uint8_t h, uint8_t procent, uint8_t x_end, uint16_t color);

//funcje wyświetlające napisy i zmienne
void hx8357d_drawChar(int x, int y, unsigned char c, uint16_t color, uint16_t bg_color, uint8_t size);
void hx8357d_puts (int x, int y, char * str, uint8_t txt_size, uint16_t color, uint16_t bg_color);
void hx8357d_puts_P (int x, int y, const char * str, uint8_t txt_size, uint16_t color, uint16_t bg_color);
void hx8357d_put_int (int x, int y, int data, uint8_t txt_size, uint16_t color, uint16_t bg_color);

//wyświetlanie Bitmap z pamięci Flash
void hx8357d_drawBitmap(int16_t x, int16_t y, const uint8_t *bitmap, int16_t w, int16_t h, uint16_t color);
void hx8357d_drawBitmap_bg_color(int16_t x, int16_t y, const uint8_t *bitmap, int16_t w, int16_t h, uint16_t color, uint16_t bg_color);
void hx8357d_drawXBitmap(int16_t x, int16_t y, const uint8_t *bitmap, int16_t w, int16_t h, uint16_t color);

#endif /* HX8357D_H_ */[/syntax]

hx8357D.c
[syntax=c]/*
* hx8357D.c
*
* Created on: 16-03-2015
* Author: Intre
*/

/***************************************************
This is our library for the Adafruit HX8357D Breakout
----> http://www.adafruit.com/products/2050

Check out the links above for our tutorials and wiring diagrams
These displays use SPI to communicate, 4 or 5 pins are required to
interface (RST is optional)
Adafruit invests time and resources providing this open source code,
please support Adafruit and open-source hardware by purchasing
products from Adafruit!

Written by Limor Fried/Ladyada for Adafruit Industries.
MIT license, all text above must be included in any redistribution
****************************************************/

#include
#include

#include "hx8357D.h"

//deklaracje zmiennych
uint16_t _width, _height;

void hx8357d_init_spi(void) {

DC_DDR |= DC;
DC_PORT |= DC;
DC_LOW;

CS_DDR |= CS;
CS_PORT |= CS;
CS_LOW;

DDRB |= (1<PORTB |= (1<SPCR |= (1<SPSR |= (1<}

// wysłanie bitu po SPI
void spi_send( uint8_t bajt ) {
SPDR = bajt;
while( !(SPSR & (1<}

// wysłanie komendy
void hx8357d_command( uint8_t cmd ) {
DC_LOW;
CLK_LOW;
CS_LOW;
spi_send(cmd);
CS_HI;
}

//wysładnie danych
void hx8357d_data( uint8_t dat ) {
DC_HI;
CLK_LOW;
CS_LOW;
spi_send (dat);
CS_HI;
}

// inicjalizacja sterownika HX8357D
void hx8357d_init (uint8_t rot) {

hx8357d_init_spi();
spi_send(0);
_delay_ms(200);

hx8357d_command(HX8357_SWRESET);

// setextc
hx8357d_command(HX8357D_SETC);
hx8357d_data(0xFF);
hx8357d_data(0x83);
hx8357d_data(0x57);

_delay_ms(300);

// setRGB which also enables SDO
hx8357d_command(HX8357_SETRGB);
hx8357d_data(0x80); //enable SDO pin!
// hx8357d_data(0x00); //disable SDO pin!
hx8357d_data(0x0);
hx8357d_data(0x06);
hx8357d_data(0x06);

hx8357d_command(HX8357D_SETCOM);
hx8357d_data(0x25); // -1.52V

hx8357d_command(HX8357_SETOSC);
hx8357d_data(0x68); // Normal mode 70Hz, Idle mode 55 Hz

hx8357d_command(HX8357_SETPANEL); //Set Panel
hx8357d_data(0x05); // BGR, Gate direction swapped

hx8357d_command(HX8357_SETPWR1);
hx8357d_data(0x00); // Not deep standby
hx8357d_data(0x15); //BT
hx8357d_data(0x1C); //VSPR
hx8357d_data(0x1C); //VSNR
hx8357d_data(0x83); //AP
hx8357d_data(0xAA); //FS

hx8357d_command(HX8357D_SETSTBA);
hx8357d_data(0x50); //OPON normal
hx8357d_data(0x50); //OPON idle
hx8357d_data(0x01); //STBA
hx8357d_data(0x3C); //STBA
hx8357d_data(0x1E); //STBA
hx8357d_data(0x08); //GEN

hx8357d_command(HX8357D_SETCYC);
hx8357d_data(0x02); //NW 0x02
hx8357d_data(0x40); //RTN
hx8357d_data(0x00); //DIV
hx8357d_data(0x2A); //DUM
hx8357d_data(0x2A); //DUM
hx8357d_data(0x0D); //GDON
hx8357d_data(0x78); //GDOFF

hx8357d_command(HX8357D_SETGAMMA);
hx8357d_data(0x02);
hx8357d_data(0x0A);
hx8357d_data(0x11);
hx8357d_data(0x1d);
hx8357d_data(0x23);
hx8357d_data(0x35);
hx8357d_data(0x41);
hx8357d_data(0x4b);
hx8357d_data(0x4b);
hx8357d_data(0x42);
hx8357d_data(0x3A);
hx8357d_data(0x27);
hx8357d_data(0x1B);
hx8357d_data(0x08);
hx8357d_data(0x09);
hx8357d_data(0x03);
hx8357d_data(0x02);
hx8357d_data(0x0A);
hx8357d_data(0x11);
hx8357d_data(0x1d);
hx8357d_data(0x23);
hx8357d_data(0x35);
hx8357d_data(0x41);
hx8357d_data(0x4b);
hx8357d_data(0x4b);
hx8357d_data(0x42);
hx8357d_data(0x3A);
hx8357d_data(0x27);
hx8357d_data(0x1B);
hx8357d_data(0x08);
hx8357d_data(0x09);
hx8357d_data(0x03);
hx8357d_data(0x00);
hx8357d_data(0x01);

hx8357d_command(HX8357_COLMOD);
hx8357d_data(0x55); // 16 bit

hx8357d_command(HX8357_MADCTL);
hx8357d_data(0xC0);

hx8357d_command(HX8357_TEON); // TE off
hx8357d_data(0x00);

hx8357d_command(HX8357_TEARLINE); // tear line
hx8357d_data(0x00);
hx8357d_data(0x02);

hx8357d_command(HX8357_SLPOUT); //Exit Sleep
_delay_ms(150);

hx8357d_command(HX8357_DISPON); // display on
_delay_ms(150);

hx8357d_setRotation(rot);
_delay_ms(25);

hx8357d_cls(black);
_delay_ms(25);

}

void hx8357d_setAddrWindow(uint16_t x0, uint16_t y0, uint16_t x1, uint16_t y1) {

hx8357d_command(HX8357_CASET); // Column addr set
hx8357d_data(x0 >> 8);
hx8357d_data(x0 & 0xFF); // XSTART
hx8357d_data(x1 >> 8);
hx8357d_data(x1 & 0xFF); // XEND

hx8357d_command(HX8357_PASET); // Row addr set
hx8357d_data(y0>>8);
hx8357d_data(y0); // YSTART
hx8357d_data(y1>>8);
hx8357d_data(y1); // YEND

hx8357d_command(HX8357_RAMWR); // write to RAM
}

// obrót ekranu 0-3
void hx8357d_setRotation(uint8_t rotation) {

hx8357d_command(HX8357_MADCTL);

if (rotation >=3 ) rotation=3; // can't be higher than 3
switch (rotation) {
case 0:
hx8357d_data(MADCTL_MX | MADCTL_MY | MADCTL_RGB);
_width = HX8357_TFTWIDTH;
_height = HX8357_TFTHEIGHT;
break;
case 1:
hx8357d_data(MADCTL_MV | MADCTL_MY | MADCTL_RGB);
_width = HX8357_TFTHEIGHT;
_height = HX8357_TFTWIDTH;
break;
case 2:
hx8357d_data( MADCTL_RGB);
_width = HX8357_TFTWIDTH;
_height = HX8357_TFTHEIGHT;
break;
case 3:
hx8357d_data(MADCTL_MX | MADCTL_MV | MADCTL_RGB);
_width = HX8357_TFTHEIGHT;
_height = HX8357_TFTWIDTH;
break;
}
}

// fill a rectangle
void hx8357d_fillRect(int16_t x, int16_t y, int16_t w, int16_t h, uint16_t color) {

// rudimentary clipping (drawChar w/big text requires this)
if((x >= _width) || (y >= _height)) return;
if((x + w - 1) >= _width) w = _width - x;
if((y + h - 1) >= _height) h = _height - y;

hx8357d_setAddrWindow (x, y, x+w-1, y+h-1);

uint8_t hi = color >> 8, lo = color;

DC_HI;
CS_LOW;

for(y=h; y>0; y--) {
for(x=w; x>0; x--) {
spi_send(hi);
spi_send(lo);
}
}
CS_HI;
}

//czyszczenie ekranu kolorem
void hx8357d_cls(uint16_t color) {
hx8357d_fillRect(0, 0, _width, _height, color);
}

// Pass 8-bit (each) R,G,B, get back 16-bit packed color
uint16_t hx8357d_color565(uint8_t r, uint8_t g, uint8_t b) {
return ((r & 0xF8) << 8) | ((g & 0xFC) << 3) | (b >> 3);
}

void hx8357d_pushColor(uint16_t color) {

DC_HI;
CS_LOW;

spi_send(color >> 8);
spi_send(color);

CS_HI;
}[/syntax]

hx8357D_graphic.c
[syntax=c]/*
* hx8357D_graphic.c
*
* Created on: 16-03-2015
* Author: Intre
*/

/*
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
#include
#include

#include "hx8357D.h"

int cursor_x, cursor_y;

void hx8357d_drawPixel(int16_t x, int16_t y, uint16_t color) {

if((x < 0) ||(x >= _width) || (y < 0) || (y >= _height)) return;

hx8357d_setAddrWindow(x,y,x+1,y+1);
DC_HI;
CS_LOW;
spi_send(color >> 8);
spi_send(color);
CS_HI;
}

void hx8357d_drawFastVLine(int16_t x, int16_t y, int16_t h, uint16_t color) {

if((x >= _width) || (y >= _height)) return;

if((y+h-1) >= _height)
h = _height-y;

hx8357d_setAddrWindow(x, y, x, y+h-1);

uint8_t hi = color >> 8, lo = color;

DC_HI;
CS_LOW;

while (h--) {
spi_send(hi);
spi_send(lo);
}
CS_HI;
}

void hx8357d_drawFastHLine(int16_t x, int16_t y, int16_t w, uint16_t color) {

if((x >= _width) || (y >= _height)) return;
if((x+w-1) >= _width) w = _width-x;
hx8357d_setAddrWindow(x, y, x+w-1, y);

uint8_t hi = color >> 8, lo = color;
DC_HI;
CS_LOW;

while (w--) {
spi_send(hi);
spi_send(lo);
}
CS_HI;
}

// Bresanham's algorithm - thx wikipedia
void hx8357d_drawLine( int x0, int y0, int x1, int y1, uint16_t color) {
int steep = abs(y1 - y0) > abs(x1 - x0);
if (steep) {
swap(x0, y0);
swap(x1, y1);
}

if (x0 > x1) {
swap(x0, x1);
swap(y0, y1);
}

int dx, dy;
dx = x1 - x0;
dy = abs(y1 - y0);

int err = dx / 2;
int ystep;

if (y0 < y1) {
ystep = 1;
} else {
ystep = -1;
}

for (; x0 <= x1; x0++) {
if (steep) {
hx8357d_drawPixel(y0, x0, color);
} else {
hx8357d_drawPixel(x0, y0, color);
}
err -= dy;
if (err < 0) {
y0 += ystep;
err += dx;
}
}
}

// Draw a circle outline
void hx8357d_drawCircle(int16_t x0, int16_t y0, int16_t r, uint16_t color) {
int16_t f = 1 - r;
int16_t ddF_x = 1;
int16_t ddF_y = -2 * r;
int16_t x = 0;
int16_t y = r;

hx8357d_drawPixel(x0 , y0+r, color);
hx8357d_drawPixel(x0 , y0-r, color);
hx8357d_drawPixel(x0+r, y0 , color);
hx8357d_drawPixel(x0-r, y0 , color);

while (x if (f >= 0) {
y--;
ddF_y += 2;
f += ddF_y;
}
x++;
ddF_x += 2;
f += ddF_x;

hx8357d_drawPixel(x0 + x, y0 + y, color);
hx8357d_drawPixel(x0 - x, y0 + y, color);
hx8357d_drawPixel(x0 + x, y0 - y, color);
hx8357d_drawPixel(x0 - x, y0 - y, color);
hx8357d_drawPixel(x0 + y, y0 + x, color);
hx8357d_drawPixel(x0 - y, y0 + x, color);
hx8357d_drawPixel(x0 + y, y0 - x, color);
hx8357d_drawPixel(x0 - y, y0 - x, color);
}
}

void hx8357d_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 if (f >= 0) {
y--;
ddF_y += 2;
f += ddF_y;
}
x++;
ddF_x += 2;
f += ddF_x;
if (cornername & 0x4) {
hx8357d_drawPixel(x0 + x, y0 + y, color);
hx8357d_drawPixel(x0 + y, y0 + x, color);
}
if (cornername & 0x2) {
hx8357d_drawPixel(x0 + x, y0 - y, color);
hx8357d_drawPixel(x0 + y, y0 - x, color);
}
if (cornername & 0x8) {
hx8357d_drawPixel(x0 - y, y0 + x, color);
hx8357d_drawPixel(x0 - x, y0 + y, color);
}
if (cornername & 0x1) {
hx8357d_drawPixel(x0 - y, y0 - x, color);
hx8357d_drawPixel(x0 - x, y0 - y, color);
}
}
}

void hx8357d_fillCircle(int16_t x0, int16_t y0, int16_t r, uint16_t color) {
hx8357d_drawFastVLine(x0, y0-r, 2*r+1, color);
hx8357d_fillCircleHelper(x0, y0, r, 3, 0, color);
}

// Used to do circles and roundrects
void hx8357d_fillCircleHelper(int16_t x0, int16_t y0, int16_t r, uint8_t cornername, int16_t delta, uint16_t color) {

int16_t f = 1 - r;
int16_t ddF_x = 1;
int16_t ddF_y = -2 * r;
int16_t x = 0;
int16_t y = r;

while (x if (f >= 0) {
y--;
ddF_y += 2;
f += ddF_y;
}
x++;
ddF_x += 2;
f += ddF_x;

if (cornername & 0x1) {
hx8357d_drawFastVLine(x0+x, y0-y, 2*y+1+delta, color);
hx8357d_drawFastVLine(x0+y, y0-x, 2*x+1+delta, color);
}
if (cornername & 0x2) {
hx8357d_drawFastVLine(x0-x, y0-y, 2*y+1+delta, color);
hx8357d_drawFastVLine(x0-y, y0-x, 2*x+1+delta, color);
}
}
}

// Draw a rectangle
void hx8357d_drawRect(int16_t x, int16_t y, int16_t w, int16_t h, uint16_t color) {
hx8357d_drawFastHLine(x, y, w, color);
hx8357d_drawFastHLine(x, y+h-1, w, color);
hx8357d_drawFastVLine(x, y, h, color);
hx8357d_drawFastVLine(x+w-1, y, h, color);
}

// Draw a rounded rectangle
void hx8357d_drawRoundRect(int16_t x, int16_t y, int16_t w, int16_t h, int16_t r, uint16_t color) {
// smarter version
hx8357d_drawFastHLine(x+r , y , w-2*r, color); // Top
hx8357d_drawFastHLine(x+r , y+h-1, w-2*r, color); // Bottom
hx8357d_drawFastVLine(x , y+r , h-2*r, color); // Left
hx8357d_drawFastVLine(x+w-1, y+r , h-2*r, color); // Right
// draw four corners
hx8357d_drawCircleHelper(x+r , y+r , r, 1, color);
hx8357d_drawCircleHelper(x+w-r-1, y+r , r, 2, color);
hx8357d_drawCircleHelper(x+w-r-1, y+h-r-1, r, 4, color);
hx8357d_drawCircleHelper(x+r , y+h-r-1, r, 8, color);
}

// Fill a rounded rectangle
void hx8357d_fillRoundRect(int16_t x, int16_t y, int16_t w, int16_t h, int16_t r, uint16_t color) {
// smarter version
hx8357d_fillRect(x+r, y, w-2*r, h, color);

// draw four corners
hx8357d_fillCircleHelper(x+w-r-1, y+r, r, 1, h-2*r-1, color);
hx8357d_fillCircleHelper(x+r , y+r, r, 2, h-2*r-1, color);
}

// Draw a triangle
void hx8357d_drawTriangle(int16_t x0, int16_t y0, int16_t x1, int16_t y1, int16_t x2, int16_t y2, uint16_t color) {
hx8357d_drawLine(x0, y0, x1, y1, color);
hx8357d_drawLine(x1, y1, x2, y2, color);
hx8357d_drawLine(x2, y2, x0, y0, color);
}

// Fill a triangle
void hx8357d_fillTriangle ( int16_t x0, int16_t y0, int16_t x1, int16_t y1, int16_t x2, int16_t y2, uint16_t color) {

int16_t a, b, y, last;

// Sort coordinates by Y order (y2 >= y1 >= y0)
if (y0 > y1) {
swap(y0, y1); swap(x0, x1);
}
if (y1 > y2) {
swap(y2, y1); swap(x2, x1);
}
if (y0 > y1) {
swap(y0, y1); swap(x0, x1);
}

if(y0 == y2) { // Handle awkward all-on-same-line case as its own thing
a = b = x0;
if(x1 < a) a = x1;
else if(x1 > b) b = x1;
if(x2 < a) a = x2;
else if(x2 > b) b = x2;
hx8357d_drawFastHLine(a, y0, b-a+1, color);
return;
}

int16_t
dx01 = x1 - x0,
dy01 = y1 - y0,
dx02 = x2 - x0,
dy02 = y2 - y0,
dx12 = x2 - x1,
dy12 = y2 - y1;
int32_t
sa = 0,
sb = 0;

// For upper part of triangle, find scanline crossings for segments
// 0-1 and 0-2. If y1=y2 (flat-bottomed triangle), the scanline y1
// is included here (and second loop will be skipped, avoiding a /0
// error there), otherwise scanline y1 is skipped here and handled
// in the second loop...which also avoids a /0 error here if y0=y1
// (flat-topped triangle).
if(y1 == y2) last = y1; // Include y1 scanline
else last = y1-1; // Skip it

for(y=y0; y<=last; y++) {
a = x0 + sa / dy01;
b = x0 + sb / dy02;
sa += dx01;
sb += dx02;
/* longhand:
a = x0 + (x1 - x0) * (y - y0) / (y1 - y0);
b = x0 + (x2 - x0) * (y - y0) / (y2 - y0);
*/
if(a > b) swap(a,b);
hx8357d_drawFastHLine(a, y, b-a+1, color);
}

// For lower part of triangle, find scanline crossings for segments
// 0-2 and 1-2. This loop is skipped if y1=y2.
sa = dx12 * (y - y1);
sb = dx02 * (y - y0);
for(; y<=y2; y++) {
a = x1 + sa / dy12;
b = x0 + sb / dy02;
sa += dx12;
sb += dx02;
/* longhand:
a = x1 + (x2 - x1) * (y - y1) / (y2 - y1);
b = x0 + (x2 - x0) * (y - y0) / (y2 - y0);
*/
if(a > b) swap(a,b);
hx8357d_drawFastHLine(a, y, b-a+1, color);
}
}

// ### % bar ###

// x, y lewy górny róg
// h wysokosc min. 3
// procent wartośc procętowa 0-100
// x_koniec pozycja końcowa
// colorkolor
void hx8357d_ProgressBar( uint16_t x_begin, uint16_t y, uint8_t h, uint8_t procent, uint8_t x_end, uint16_t color){

uint8_t i;
uint8_t set2 = (x_end*procent)/100;

hx8357d_drawRect( x_begin-1, y, x_end+1, h, color);

for( i=0; i < set2; i++){
hx8357d_drawFastVLine( x_begin+i, y+1, h-2, color);
}
for( ; i < x_end-1; i++){
hx8357d_drawFastVLine( x_begin+i, y+1, h-2, !color);
}
}

// rysuj znak/literę
void hx8357d_drawChar(int x, int y, unsigned char c, uint16_t color, uint16_t bg_color, uint8_t size) {

if((x >= _width) || // Clip right
(y >= _height) || // Clip bottom
((x + 6 * size - 1) < 0) || // Clip left
((y + 8 * size - 1) < 0)) // Clip top
return;

for (int8_t i=0; i<6; i++ ) {
uint8_t line;
if (i == 5)
line = 0x0;
else
line = pgm_read_byte(font+(c*5)+i);
for (int8_t j = 0; j<8; j++) {
if (line & 0x1) {
if (size == 1) // default size
hx8357d_drawPixel(x+i, y+j, color);
else { // big size
hx8357d_fillRect(x+(i*size), y+(j*size), size, size, color);
}
} else if (bg_color != color) {
if (size == 1) // default size
hx8357d_drawPixel(x+i, y+j, bg_color);
else { // big size
hx8357d_fillRect(x+i*size, y+j*size, size, size, bg_color);
}
}
line >>= 1;
}
}
}

// wyświetl tekst z pamięci RAM
void hx8357d_puts (int x, int y, char * str, uint8_t txt_size, uint16_t color, uint16_t bg_color) {

cursor_x = x; cursor_y = y;

while (*str ) {

hx8357d_drawChar (cursor_x, cursor_y, *str++, color, bg_color, txt_size);
cursor_x += txt_size*6;
}
}

// wyświetl tekst z pamięci FLASH
void hx8357d_puts_P (int x, int y, const char * str, uint8_t txt_size, uint16_t color, uint16_t bg_color) {

cursor_x = x; cursor_y = y;

register char c;
while (*str ) {
c = pgm_read_byte (str++);
hx8357d_drawChar (cursor_x, cursor_y, c, color, bg_color, txt_size);
cursor_x += txt_size*6;
}
}

// wyświetl zmienną
void hx8357d_put_int (int x, int y, int data, uint8_t txt_size, uint16_t color, uint16_t bg_color) {
char buf[16];
hx8357d_puts (x, y, itoa (data, buf, 10), txt_size, color, bg_color);
}

// ### wyświetlanie map bitowych ###

//jednokolorowa bez tła
void hx8357d_drawBitmap(int16_t x, int16_t y, const uint8_t *bitmap, int16_t w, int16_t h, uint16_t color) {

int16_t i, j, byteWidth = (w + 7) / 8;

for(j=0; j for(i=0; i if(pgm_read_byte(bitmap + j * byteWidth + i / 8) & (128 >> (i & 7))) {
hx8357d_drawPixel(x+i, y+j, color);
}
}
}
}

//jednokolorowa z tłem
void hx8357d_drawBitmap_bg_color(int16_t x, int16_t y, const uint8_t *bitmap, int16_t w, int16_t h, uint16_t color, uint16_t bg_color) {

int16_t i, j, byteWidth = (w + 7) / 8;

for(j=0; j for(i=0; i if(pgm_read_byte(bitmap + j * byteWidth + i / 8) & (128 >> (i & 7))) {
hx8357d_drawPixel(x+i, y+j, color);
}
else {
hx8357d_drawPixel(x+i, y+j, bg_color);
}
}
}
}

//Draw 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
void hx8357d_drawXBitmap(int16_t x, int16_t y, const uint8_t *bitmap, int16_t w, int16_t h, uint16_t color) {

int16_t i, j, byteWidth = (w + 7) / 8;

for(j=0; j for(i=0; i if(pgm_read_byte(bitmap + j * byteWidth + i / 8) & (1 << (i % 8))) {
hx8357d_drawPixel(x+i, y+j, color);
}
}
}
}[/syntax]

intre_demo.h
[syntax=c]/*
* intre_demo.h
*
* Created on: 16-03-2015
* Author: Intre
*/

#ifndef INTRE_DEMO_H_
#define INTRE_DEMO_H_

typedef struct {
uint16_t term1_color;
uint16_t term2_color;
uint16_t term1_font_color;
uint16_t term1_out_color;
uint16_t term2_font_color;
uint16_t term2_in_color;
uint16_t termo_background_color;
uint16_t clock_date_background;
uint16_t date_font_color;
uint16_t clock_font_color;
uint16_t day_of_week_font_color;
uint16_t day_of_week_background;
uint16_t weather_background;
uint16_t weather_font_color;
uint16_t cloud_color;
uint16_t cloud_background;
uint16_t umbrella_color;
uint16_t intre_font_color;
uint16_t intre_background;
uint16_t top_background;
uint16_t light_color;
uint16_t wifi_color;
uint16_t battery_color;
uint16_t posts_color;
uint16_t higro_font_color;

} TCOLOR;

extern TCOLOR scheme;
extern uint8_t higro;
extern char week_tab [7][13];

void testLines(uint16_t color);
void testFastLines(uint16_t color1, uint16_t color2);
void testRects(uint16_t color);
void testFilledRects(uint16_t color1, uint16_t color2);
void testFilledCircles(uint8_t radius, uint16_t color);
void testCircles(uint8_t radius, uint16_t color);
void testTriangles(uint8_t size);
void testFilledTriangles(int size);
void testRoundRects(int size);
void testFilledRoundRects(int size);

void intre_matrix (void);
void icons (void);
void buttons (void);

void intre_HX8357D_library_demo (void);
void set_higrometer_time (uint8_t hour, uint8_t minute);
void higrometer_colors (uint8_t skin_no);
void higrometer_scheme (void);
void intre_higrometer_demo (void);
void digital_clock (void);
void umbrella_on (void);
void umbrella_off (void);
void procent_higro (void);

#endif /* INTRE_DEMO_H_ */[/syntax]

intre_demo.c
[syntax=c]/*
* intre_demo.c
*
* Created on: 16-03-2015
* Author: Intre
*/

#include
#include

#include "intre_demo.h"

#include "..//INTRE_HX8357D/hx8357D.h"
#include "..//BITMAPS/bitmaps.h"
#include "..//TIMERS/timers.h"

TCOLOR scheme;

uint8_t higro, load;

char week_tab [7][13]= {"poniedziałek", "wtorek", "środa", "czwartek", "piątek", "sobota", "niedziela" };

void set_higrometer_time (uint8_t hour, uint8_t minute){
clock.hh = hour;
clock.min = minute;
}

void intre_HX8357D_library_demo (void){

hx8357d_drawBitmap_bg_color(150, 50, intre, 183, 57, blue, black);
hx8357d_puts(180, 120 ,"prezentuje:", 2, white, black);
hx8357d_puts(100, 175 ,"Adafruit 480 x 320 TFT LCD", 2, yellow, black);
hx8357d_puts(160, 210 ,"Breakout Board", 2, green, black);
_delay_ms(3000);

hx8357d_cls(black);
hx8357d_puts(190, 110 ,"wczytywanie...", 2, white, black);
hx8357d_drawBitmap_bg_color(155, 100, hourglass, 31, 31, white, black);

for (load =0; load<100; load++) {
hx8357d_ProgressBar( 130, 170, 30, load, 240, orange);
_delay_ms(20);
}

hx8357d_cls(red);
_delay_ms(200);

hx8357d_cls(green);
_delay_ms(200);

hx8357d_cls(blue);
_delay_ms(200);

testLines(yellow);
_delay_ms(2000);

testLines(white);
_delay_ms(2000);

hx8357d_cls(black);
testFastLines(red, black);
_delay_ms(300);

testFastLines(navy, black);
_delay_ms(300);

hx8357d_cls(black);
testCircles(30, green_yellow);
_delay_ms(2000);

hx8357d_cls(black);
testFilledCircles(30, blue);
_delay_ms(2000);
hx8357d_cls(black);

testFilledTriangles(155);
_delay_ms(2000);

testTriangles(155);
_delay_ms(2000);

hx8357d_cls(black);
testFilledRoundRects(320);
_delay_ms(2000);

testRoundRects(320);
_delay_ms(2000);

hx8357d_cls(black);
testFilledRects (blue, yellow);
_delay_ms(2000);

hx8357d_cls(black);
intre_matrix ();
_delay_ms(2000);

hx8357d_cls(black);
buttons ();
_delay_ms(2000);

hx8357d_cls(black);
icons ();
_delay_ms(2000);

hx8357d_cls(black);
higrometer_colors (2);
higrometer_scheme ();
_delay_ms(2000);

hx8357d_cls(black);
higrometer_colors (1);
higrometer_scheme ();
_delay_ms(2000);

hx8357d_cls(black);
higrometer_colors (3);
higrometer_scheme ();
_delay_ms(2000);

hx8357d_cls(white);
higrometer_colors (4);
higrometer_scheme ();
_delay_ms(2000);

}

void intre_higrometer_demo (void){
if(clock.sec_flag) {

digital_clock ();

if( 0 == (clock.sec%3) ) umbrella_on();
if( 1 == (clock.sec%3) ) umbrella_off();

clock.sec_flag=0;
}

if (!clock.Timer1) {
clock.Timer1 = 500;
procent_higro ();
}
}

void higrometer_scheme (void) {

//top
hx8357d_drawBitmap_bg_color(0, 0, intre, 183, 57, scheme.intre_font_color, scheme.intre_background);
hx8357d_drawBitmap_bg_color(183, 0, light, 69, 57, scheme.light_color, scheme.top_background);
hx8357d_drawBitmap_bg_color(240, 0, wi_fi, 32, 57, scheme.wifi_color, scheme.top_background);
hx8357d_drawBitmap_bg_color(272, 0, battery, 52, 57, scheme.battery_color, scheme.top_background);
hx8357d_fillRect(324, 0, 89, 57, scheme.top_background);
hx8357d_puts(380, 18 , "%", 3, scheme.higro_font_color, scheme.top_background);
hx8357d_drawBitmap_bg_color(413, 0, posts, 67, 57, scheme.posts_color, scheme.top_background);

//cloud
hx8357d_fillRect(0, 57, 183, 205, scheme.cloud_background);

//termo
hx8357d_drawBitmap_bg_color(183, 57, out, 100, 26, scheme.term1_out_color, scheme.termo_background_color);
hx8357d_puts(185, 63 ,"out", 2, scheme.term1_out_color, scheme.termo_background_color);
hx8357d_fillRect(183, 83, 100, 73, scheme.termo_background_color);
hx8357d_put_int(215, 95 , 12, 6, scheme.term1_font_color, scheme.termo_background_color);
hx8357d_drawBitmap_bg_color(283, 57, term1, 52, 99, scheme.term1_color, scheme.termo_background_color);
hx8357d_fillRect(334, 57, 104, 99, scheme.termo_background_color);
hx8357d_puts(350, 63 ,"in", 2, scheme.term2_in_color, scheme.termo_background_color);
hx8357d_put_int(370, 95 , 21, 6, scheme.term2_font_color, scheme.termo_background_color);
hx8357d_drawBitmap_bg_color(438, 57, term2, 42, 99, scheme.term2_color, scheme.termo_background_color);

//clock date
hx8357d_fillRect(183, 156, 298, 106, scheme.clock_date_background);
hx8357d_puts(250, 230 , "15.03.2015", 3, scheme.date_font_color, scheme.clock_date_background);
hx8357d_fillRect(0, 261, 183, 60, scheme.weather_background);
hx8357d_fillRect(183, 261, 298, 60, scheme.day_of_week_background);
hx8357d_puts(245, 280 , week_tab[0], 3, scheme.day_of_week_font_color, scheme.day_of_week_background);
hx8357d_puts (270, 170 , ":", 6, scheme.clock_font_color, scheme.clock_date_background);
hx8357d_puts (370, 170 , ":", 6, scheme.clock_font_color, scheme.clock_date_background);

digital_clock();

//weather
hx8357d_puts(20, 275 , "deszcz", 4, scheme.weather_font_color, scheme.weather_background);

//cloud
hx8357d_drawBitmap_bg_color(0, 57, cloud, 183, 205, scheme.cloud_color, scheme.cloud_background);
hx8357d_drawBitmap_bg_color(124, 57, umbrella, 59, 59, scheme.umbrella_color, scheme.cloud_background);

}

void digital_clock (void){

if (clock.hh <10){
hx8357d_put_int (200, 170 , 0, 6, scheme.clock_font_color, scheme.clock_date_background);
hx8357d_put_int (235, 170 , clock.hh, 6, scheme.clock_font_color, scheme.clock_date_background);
}
else
hx8357d_put_int (200, 170 , clock.hh, 6, scheme.clock_font_color, scheme.clock_date_background);

if (clock.min <10){
hx8357d_put_int (300, 170 , 0, 6, scheme.clock_font_color, scheme.clock_date_background);
hx8357d_put_int (335, 170 , clock.min, 6, scheme.clock_font_color, scheme.clock_date_background);
}
else
hx8357d_put_int (300, 170 , clock.min, 6, scheme.clock_font_color, scheme.clock_date_background);

if (clock.sec <10){
hx8357d_put_int (400, 170 , 0, 6, scheme.clock_font_color, scheme.clock_date_background);
hx8357d_put_int (435, 170 , clock.sec, 6, scheme.clock_font_color, scheme.clock_date_background);
}
else
hx8357d_put_int (400, 170 , clock.sec, 6, scheme.clock_font_color, scheme.clock_date_background);

}

void umbrella_on (void){
hx8357d_drawBitmap_bg_color(124, 57, umbrella, 59, 59, scheme.umbrella_color, scheme.cloud_background);
}

void umbrella_off (void){
hx8357d_fillRect(124, 57, 59, 59, scheme.cloud_background);
}

void procent_higro (void){
higro++;
if (higro >=99) higro=0;
if (higro <=9){
hx8357d_put_int(340, 18 , 0, 3, scheme.higro_font_color , scheme.top_background);
hx8357d_put_int(358, 18 , higro, 3, scheme.higro_font_color , scheme.top_background);
}
else
hx8357d_put_int(340, 18 , higro, 3, scheme.higro_font_color, scheme.top_background);

}

void icons (void){
hx8357d_drawBitmap_bg_color(103, 49, watch, 46, 42, blue, black);
hx8357d_drawBitmap_bg_color(149, 49, trash, 65, 42, white, black);
hx8357d_drawBitmap_bg_color(214, 49, coffee, 62, 42, yellow, black);
hx8357d_drawBitmap_bg_color(276, 49, no, 62, 42, red, black);
hx8357d_drawBitmap_bg_color(336, 49, arow, 46, 42, green, black);
hx8357d_drawBitmap_bg_color(103, 137, anten, 46, 45, magenta, black);
hx8357d_drawBitmap_bg_color(149, 137, umbro2, 65, 45, orange, black);
hx8357d_drawBitmap_bg_color(214, 137, tank, 62, 45, cyan, black);
hx8357d_drawBitmap_bg_color(276, 137, music, 60, 45, blue, black);
hx8357d_drawBitmap_bg_color(336, 137, cd, 46, 45, white, black);
hx8357d_drawBitmap_bg_color(103, 228, talk, 46, 42, green, black);
hx8357d_drawBitmap_bg_color(149, 228, lupe, 65, 42, red, black);
hx8357d_drawBitmap_bg_color(214, 228, arow2, 65, 42, yellow, black);
hx8357d_drawBitmap_bg_color(279, 228, armchair, 60, 42, magenta, black);
hx8357d_drawBitmap_bg_color(336, 228, folder, 46, 42, orange, black);
}

void intre_matrix (void){
hx8357d_drawBitmap_bg_color(40, 20, intre, 183, 57, blue, black);
hx8357d_drawBitmap_bg_color(250, 20, intre, 183, 57, red, black);
hx8357d_drawBitmap_bg_color(40, 77, intre, 183, 57, white, black);
hx8357d_drawBitmap_bg_color(250, 77, intre, 183, 57, yellow, black);
hx8357d_drawBitmap_bg_color(40, 134, intre, 183, 57, cyan, black);
hx8357d_drawBitmap_bg_color(250, 134, intre, 183, 57, magenta, black);
hx8357d_drawBitmap_bg_color(40, 191, intre, 183, 57, green, black);
hx8357d_drawBitmap_bg_color(250, 191, intre, 183, 57, blue, black);
hx8357d_drawBitmap_bg_color(40, 248, intre, 183, 57, red, black);
hx8357d_drawBitmap_bg_color(250, 248, intre, 183, 57, white, black);
}

void buttons (void){
hx8357d_fillRoundRect(25, 15, 230, 90, 45, red);
hx8357d_puts (105, 50, "SAVE", 3, white, red);
hx8357d_fillRoundRect(25, 115, 230, 90, 35, blue);
hx8357d_puts (105, 150, "LOAD", 3, yellow, blue);
hx8357d_fillRoundRect(25, 215, 230, 90, 20, green);
hx8357d_puts (100, 250, "CANEL", 3, black, green);
hx8357d_fillRoundRect(280, 15, 90, 90, 20, green_yellow);
hx8357d_fillRoundRect(280, 115, 90, 90, 20, cyan);
hx8357d_fillCircle(425, 160, 42, orange);
hx8357d_fillRoundRect(280, 215, 190, 90, 25, white);
hx8357d_fillRoundRect(290, 225, 170, 70, 25, blue);
hx8357d_puts (315, 245, "INTRE", 4, white, blue);
hx8357d_fillTriangle (425, 15, 380, 105, 470, 105, magenta);
hx8357d_drawBitmap_bg_color(295, 38, lupe, 65, 42, blue, green_yellow);
hx8357d_drawBitmap_bg_color(295, 140, trash, 65, 42, red, cyan);
hx8357d_drawBitmap_bg_color(400, 140, folder, 46, 42, black, orange);
hx8357d_drawBitmap_bg_color(403, 61, arow, 46, 42, white, magenta);
}

void testLines(uint16_t color) {

int x1, y1, x2, y2,
w = _width,
h = _height;

hx8357d_cls(black);

x1 = y1 = 0;
y2 = h - 1;

for(x2=0; x2 x2 = w - 1;
for(y2=0; y2
}

void testFastLines(uint16_t color1, uint16_t color2) {

int x, y, w = _width, h = _height;

hx8357d_cls(black);

for(y=0; y for(x=0; x

}

void testRects(uint16_t color) {

int n, i, i2, cx = _width / 2, cy = _height / 2;

hx8357d_cls(black);
n = HX8357_TFTWIDTH;

for(i=2; i i2 = i / 2;
hx8357d_drawRect(cx-i2, cy-i2, i, i, color);
}
}

void testFilledRects(uint16_t color1, uint16_t color2) {

int n, i, i2, cx = _width / 2 - 1, cy = _height / 2 - 1;

hx8357d_cls(black);
n = HX8357_TFTWIDTH;

for(i=n; i>0; i-=6) {
i2 = i / 2;

hx8357d_fillRect(cx-i2, cy-i2, i, i, color1);
hx8357d_drawRect(cx-i2, cy-i2, i, i, color2);
}
}

void testFilledCircles(uint8_t radius, uint16_t color) {

int x, y, w = _width, h = _height, r2 = radius * 2;

// hx8357d_cls(black);

for(x=radius; x for(y=radius; y hx8357d_fillCircle(x, y, radius, color);
}
}
}

void testCircles(uint8_t radius, uint16_t color) {

int x, y, r2 = radius * 2, w = _width + radius, h = _height + radius;

// Screen is not cleared for this one -- this is
// intentional and does not affect the reported time.

for(x=0; x for(y=0; y hx8357d_drawCircle(x, y, radius, color);
}
}
}

void testTriangles(uint8_t size) {

int i, cx = _width / 2 - 1, cy = _height / 2 - 1;

// hx8357d_cls(black);
//n = size;

for(i=0; i hx8357d_drawTriangle(
cx , cy - i, // peak
cx - i, cy + i, // bottom left
cx + i, cy + i, // bottom right
hx8357d_color565(200, 20, i));
}
}

void testFilledTriangles(int size) {

int i, cx = _width / 2 - 1, cy = _height / 2 - 1;

hx8357d_cls(black);
i = size;

for(i=170; i>10; i-=5) {

hx8357d_fillTriangle(cx, cy - i, cx - i, cy + i, cx + i, cy + i,
hx8357d_color565(0, i, i));

hx8357d_drawTriangle(cx, cy - i, cx - i, cy + i, cx + i, cy + i,
hx8357d_color565(i, i, 0));
}
}

void testRoundRects(int size) {

int w, i, i2,cx = _width / 2 , cy = _height / 2 ;

// hx8357d_cls(black);
w = size;

for(i=0; i i2 = i / 2 - 2;
hx8357d_drawRoundRect(cx-i2, cy-i2, i, i, i/8, hx8357d_color565(i, 100, 100));
}
}

void testFilledRoundRects(int size) {

int i, i2, cx = _width / 2 + 10, cy = _height / 2 + 10;

hx8357d_cls(black);
//i = size;

for(i = size- 20; i>20; i-=6) {
i2 = i / 2;
hx8357d_fillRoundRect(cx-i2, cy-i2, i-20, i-20, i/8, hx8357d_color565(100, i/2, 100));
}
}[/syntax]

timers.h
[syntax=c]/*
* timers.h
*
* Created on: 16-03-2015
* Author: Intre
*/

#ifndef TIMERS_H_
#define TIMERS_H_

// ustalamy czy korzystamy z pinu do wł/wył zasilania karty SD
#define USE_A32A1
#define USE_A644PA0 // ##CAUTION## works properly only 3,3V

//zmienne dla odmierzania czasu
volatile typedef struct {
uint8_t sec_flag;
uint8_t cnt;
uint8_t sec;
uint8_t min;
uint8_t hh;
uint16_t Timer1;
uint16_t Timer2;
} TTIME;

extern volatile TTIME clock;

// funkcja inicjalizująca Taimer 2
extern void timer2_init (void);

#endif /* TIMERS_H_ */[/syntax]

timers.c
[syntax=c]/*
* timers.c
*
* Created on: 16-03-2015
* Author: Intre
*/

#include
#include

#include "timers.h"

volatile TTIME clock;

// inicjalizacja TIMER 2
// Zoptymalizowane dla F_CPU = 18 432 000 MHz
void timer2_init (void) {

#if USE_A32A == 1
TCCR2 |= (1< TCCR2 |= (1< OCR2 = 179; // 10 ms thx mkAVRCaclulator http://atnel.pl/mkavrcalculator.html
TIMSK |= (1<#endif

#if USE_A644PA == 1
TCCR2A |= (1< TCCR2B |= (1< OCR2A = 179; // 10 ms thx mkAVRCaclulator http://atnel.pl/mkavrcalculator.html
TIMSK2 |= (1<#endif
}

//obsługa przerwania
#if USE_A32A == 1
ISR(TIMER2_COMP_vect) {
#endif

#if USE_A644PA == 1
ISR(TIMER2_COMPA_vect) {
#endif

clock.cnt++;
if(clock.cnt>99) {
{
clock.sec_flag=1;
clock.sec++;
if(clock.sec>59)
{ clock.sec = 0;
clock.min++;
if(clock.min>59) {
clock.min = 0;
clock.hh++;
}
if(clock.hh>24) {
clock.hh = 0;
}
}
clock.cnt = 0;
}
}
uint16_t n;
n = clock.Timer1;
if (n) clock.Timer1 = --n;
n = clock.Timer2;
if (n) clock.Timer2 = --n;
}[/syntax]

I jak?
No cóż trochę się naklepałem, jeszcze są pliki z bitmapami i ustawieniami skórki dla dema higrometru ale to zostawiam do obejrzenia w załączniku. Ogólnie nie mam pojęcia czy tą bibliotekę jak również program demonstracyjny napisałem dobrze czy źle, to już pozostawiam do oceny w waszej gestii.

Napiszę że na pewno mi ta biblioteka działa i ja osobiście jestem z niej zadowolony, funkcjonalność jaką ja potrzebuje do jakiś swoich projektów mam wystarczającą, rzekłbym aż nad to.
Biblioteka w załączniku jest skompilowana na procesor Atmega 32A pracująca z zegarem 18 432 000, z innymi mniejszymi kwarcami też chodzi ale nie zalecałbym niczego niżej niż 16Mhz - już mocno zwalnia. Testowałem ja na różnych procesorach np. A32A, A128 (po odchudzeniu nawet na A8 najmniejszy jaki próbowałem) jak i również na A644PA oraz A1284P i tu mam małe pytanie bo zagadką dla mnie jest to że o ile ze starszymi wymienionymi procesorami komunikacja SPI przy 5V działa idealnie bez zastrzeżeń to jak skompiluje tą bibliotekę na nowsze procesory serii 644 itd. to amen, złe działanie, defakto krzaki na ekranie, niestabilność, masakra. Jednakże jak przestawię tylko napięcie zasilania na 3,3V lub dam dodatkowy dzielnik napięcia to ręka odjoł biblioteka działa tak samo dobrze jak na A32 itp. o co tu chodzi, coś się zmieniło w nowszych procesorach, analizowałem notę jest tam coś o zasilaniu w przypadku używania SPI, coś powiązane z UART że trzeba dać 0 wrejestr PWR, ale domyślnie są 0 no nie jasne to dla mnie, może ktoś z bardziej doświadczonych kolegów wyjaśni o co chodzi, mówię przestawiam na 3,3V i jest ok, a ze starszymi procesorami obojętnie czy na 5V czy na 3,3V jest też ok.

Z innych uwag jakie mam albo mi nie wyszły to wyświetlanie zmiennej z pamięci flash, ona się wyświetla na ekranie ale oprócz niej jakieś krzaki, może ktoś obejrzeć funkcje i mi podpowiedzieć jaki mam błąd lub może ficzer trzeba zrobić by było ok Już nie aktualne bo poprawione - aktualizacja biblioteki w załączniku

W demie aż się pewnie prosiło o latający napis spoza ekranu na wyświetlacz, ot taka pętelka - no cóż mała masakra z prędkością wyświetlania jakby AVRkowi pary zabrakło jak cały napis wjedzie dlatego z prezentacji tego zrezygnowałem ale kto wie może coś źle robię....

Z innych rzeczy jak ktoś bliżej się przyjrzy temu wyświetlaczowi to stwierdzi że ma on dotykowy rezystancjny ekran oraz czytnik kart MicroSD, i to się zgadza wszystko jest. Jeszcze tego nie opanowałem z jednej strony sprzętowo bo chcę dotykowy ekran zrobić na opisanym przez Mirka układzie STMPE811 https://www.sklep.atnel.pl/pl/searchquery/STMPE811/1/phot/5?url=STMPE811 i tutaj walczę z przylutowaniem jego bo jest ciut za duży ale myślę że za jakiś czas go opanuje i dodam stosowną aktualizacje biblioteki o funkcjonalność dotyku ale opartą o kod Mirka z zielonej książki więc by go uruchomić będzie wymagane dogranie jej sobie. Czytnik kart SD udało mi się bez większych problemów odpalić w wyświetlaczu również za pomocą biblioteki PetiFS Mirka z zielonej książki jednakże poległem na razie na pisaniu funkcji wyświetlającej zdjęcia z karty, no cóż jest to szerszy problem który opisze w nowym wątku ze stosownymi pytaniami oraz niejasnościami jakie mam i jak to opanuję również dodam zaktualizowaną funkcjonalność. Wyświetlacz ma jeszcze tryb 8-bit ja jednakże raczej nie będę go oprogramowywać - chociaż może kiedyś dla zabawy to też kod zamieszczę.

To z grubsza, tyle jak są jakieś pytania czy nie jasności to chętnie odpowiem. Dodam jeszcze że ten wyświetlacz w PL można nabyć np. w sklepie Botland:
http://botland.com.pl/wyswietlacze-graficzne/2666-wyswietlacz-dotykowy-tft-lcd-35-320-x-480-z-czytnikiem-microsd.html

I jeszcze napisze dla malkontentów, powiem wam że jestem przeszczęsliwy, wniebowzięty wręcz że po jakimś tam czasie, w sumie nie długim ja wiem roku-póltorej nauki języka C od 0 z Mirkiem, jego poradnikami oraz książkami opanowałem sobie sam bez niczyjej pomocy obsługę jakiegoś tam przypadkowego wyświetlacza LCD TFT, którego widzę pierwszy raz na oczy w jakiś tydzień wraz z programem demonstracyjnym. I to jest dla mnie najlepsze wręcz bezcenne, a o Mirku świadczy że robotę jaką robi robi ją bardzo dobrze

Statystyki: Napisane przez Intre — 18 mar 2015, o 23:59

ATNEL tech-forum

Re: INTRE 3,5" 480 x 320 TFT LCD HX8357D SPI Library

Re: INTRE 3,5" 480 x 320 TFT LCD HX8357D SPI Library

Re: INTRE 3,5" 480 x 320 TFT LCD HX8357D SPI Library

Re: INTRE 3,5" 480 x 320 TFT LCD HX8357D SPI Library

Re: INTRE 3,5" 480 x 320 TFT LCD HX8357D SPI Library

Re: INTRE 3,5" 480 x 320 TFT LCD HX8357D SPI Library

Re: INTRE 3,5" 480 x 320 TFT LCD HX8357D SPI Library

Re: INTRE 3,5" 480 x 320 TFT LCD HX8357D SPI Library

Re: INTRE 3,5" 480 x 320 TFT LCD HX8357D SPI Library

INTRE 3,5" 480 x 320 TFT LCD HX8357D SPI Library