ATNEL tech-forum 2015-10-16T19:41:05+01:00 https://forum.atnel.pl/feed.php?f=23&t=13266&mode 2015-10-16T19:41:05+01:00 2015-10-16T19:41:05+01:00 https://forum.atnel.pl/viewtopic.php?t=13266&p=142655#p142655 <![CDATA[[BIBLIOTEKA] LPH9157-2 wyświetlacz TFT 176x132]]> Od zawsze miałem słabość do kolorowych wyświetlaczy LCD. Gdy zaczynałem moją przygodę z programowaniem (bascom), chciałem jak najszybciej nauczyć się obsługi takich wyświetlaczy.
Potem gdzieś w sieci ujrzałem ten filmik, autorstwa Pana Mirka:
iframe

I można by powiedzieć, że był on takim wzorem dla mnie, co chciałbym osiągnąć. Jakiś czas temu wykorzystałem już jeden wyświetlacz z Siemensa C65, w projekcie, który z resztą prezentowałem tutaj na forum, "namiastka komputera pokładowego". Ale to był bascom...

Ktoś może zapytać, po co bawić się "nieznanymi" wyświetlaczami, skoro teraz można kupić dedykowany w dość dobrej cenie. A no można, ale większość z nas posiada duże ilość starej elektroniki, no i co tu z tym zrobić? Wyrzucić szkoda, trzeba wykorzystać.

Tym razem na celownik wziąłem troszkę większy wyświetlacz, pochodzi z telefonu Siemens C75. Kiedyś te telefony były popularne i pewnie u niejednego gdzieś się taki wala. Jego rozdzielczość 132x176 16bitów. W telefonach tych były montowane dwa rodzaje wyświetlaczy, jeden z zieloną płytką o oznaczeniach LPH9157-2 (biblioteka jest właśnie dla niego), oraz drugi z żółtą płytką, nazywany ALPS.

Jako, że w połowie września podjąłem decyzję o nauce C i zakupiłem BB, uznałem że najlepszym sposobem do nauki będzie wykonanie czegoś w praktyce (oczywiście po wcześniejszym przeczytaniu książki od A do Z :P ).

O wyświetlaczu nie miałem za dużo informacji, jedynie gdzieś na zagranicznych stronach jakieś komendy sterujące. Prawdę mówiąc do tej pory nie wiem, jaki dokładnie sterownik tam siedzi, wiem że jest on w większości zgodny z ILI9163. I to na podstawie dokumentacji tego sterownika opierałem się podczas wszelkich testów. Różnice są między innymi w rozdzielczości wyświetlacza, ilość wysyłanych parametrów.

Na początku opis wyprowadzeń wyświetlacza:
Obrazek

Jak widać, nie ma większego problemu, aby dolutować się tam z taśmą.

Minimalne podłączanie wygląda następująco:
Obrazek

Oczywiście to jest minimalne, warto dodać jednak rezystor od CS do plusa zasilania.
Co do pinu RST mamy dwie możliwości, podłączyć go na stałe do plusa zasilania, lub do mikroprocesora. Trzeba to wybrać też w bibliotece. Jeśli podłączamy do plusa, wykonywany jest podczas inicjalizacji reset programowy, jeśli sterujemy linią RST wykonywany jest reset sprzętowy, są tam minimalne różnice co do wartości kilku rejestrów po resecie, mało istotne z naszego punktu obsługi wyświetlacza.

Gdyby kogoś przerażała potrzeba dodatkowego napięcia 12V dla zasilenia podświetlenia spokojnie, są dedykowane układy driverów step-up. Piny GND i LED- nie są połączone.

Wyświetlacz ten zasilany jest typowo(w telefonie) napięciem 2,9V, jednak z napięciem 3.3V również poprawnie działa.

A więc aby nie zanudzać kod:
display.h -tutaj dokonujemy wszelkich ustawień
[syntax=c]//-----------------------------------------------------------------------------------------------------------
// *** Obsługa kolorowego wyświetlaczy TFT 132x176 LPH9157-2 ***
//
//Biblioteka do obsługi kolorowego wyświetlaca TFT z telefonu Siemens C75 i podobne.
//Umożliwia wyświetlanie bitmap 24 bitowych RGB888 oraz 16 bitowych RGB565 z karty SD.
//
//
// Data : październik 2015
// Autor : Anonimowy
//----------------------------------------------------------------------------------------------------------
#ifndef DISPLAY_H_
#define DISPLAY_H_

//----------------------------------------------------------------------------------------
//
//Ustawienie pinów sprzętowego SPI
//
//----------------------------------------------------------------------------------------
#define MOSI PB5
#define SCK PB7
#define CSPB4
#define SPI_DDRDDRB
#define SPI_PORTPORTB
//Makrodefinicje sterujące linią CS wyświetlacza
#define CS_ON SPI_PORT &= ~(1<<CS)
#define CS_OFF SPI_PORT |= (1<<CS)

//----------------------------------------------------------------------------------------
//
//Ustawienie pozostałych pinów wyświetlacza
//
//----------------------------------------------------------------------------------------
#define RSPB2
#define RS_DDRDDRB
#define RS_PORTPORTB

//#define RSTPB3//zakomentuj, jeśli RST połączony z VCC
#define RST_DDRDDRB
#define RST_PORTPORTB

//----------------------------------------------------------------------------------------
//
//Parametry pracy wyświetlacza
//
//----------------------------------------------------------------------------------------
#define USE_MEM_CONTROL0x80//orientacja wyświetlacza
#define USE_PALETTE0x05//paleta kolorów, 0x05 - 16 bit, 0x02 - 8bit
//odkomentuj, jeśli wykorzystujesz tryb częściowy wyświetlacza
//#define USE_SPARTIAL 20//adres początku trybu częściowego wyświetlacza
//#define USE_EPARTIAL 155//adres końca trybu częściowego wyświetlacza
#define IMG_BUF2048//rozmiar buforu zdjęcia

//----------------------------------------------------------------------------------------
//
//USTAWIENIA KOMPILACJI
//
//1 - oznacza WŁĄCZENIE do kompilacji
//0 - oznacza wyłączenie z kompilacji (funkcja niedostępna)
//
//----------------------------------------------------------------------------------------
#define USE_INT_DISPLAY1//wyświetla zmienną jako liczbę dziesiętną
#define USE_TEXT_DISPLAY1//wyświetla napis z pamięci programu
#define USE_IMG_DISPLAY1//wyświetla zdjęcie z karty SD
#define USE_CLS_DISPLAY1//wypełnia wyświetlacz danym kolorem
#define USE_LINE_DISPLAY1//rysuje linie
#define USE_CIRCLE_DISPLAY1//rysuje okręg
#define USE_DRAW_DISPLAY1//rysuje prostokąt wypełniony kolorem
//----------------------------------------------------------------------------------------

//komendy sterujące
#define LCD_NOP0x00//kończy zapis/odczyt ramki z pamięci
#define SOFT_RST0x01//wykonuje programowy reset wyświetlacza
#define SLEEP_IN0x10//wprowadza wyświetlacz w tryb uśpienia, zmiejszając pobór prądu
#define SLEEP_OUT0x11//wyprowadza wyświetlacz z trybu uśpienia
#define PARTIAL_MODE0x12//włącza tryb częściowy wyświetlacza
#define NORMAL_MODE0x13//przywraca tryb normalne pracy po trybie częściowym lub przewijaniu
#define INVERSION_OFF0x20//wyłącza tryb inwersji (odwrócenia) kolorów
#define INVERSION_ON0x21//włącza tryb inwersji (odwrócenia) kolorów
#define GAMMA_SET0x26//umożliwia wybór jednej z 4 krzywych gamma, domyśle 0x01
//Parametr 0x01 -1 ; 0x02 - 2 ; 0x04 - 3 ; 0x08 - 4
#defineDISPLAY_OFF0x28//deaktywuje wyświetlanie, wyświetla pustą stronę
#define DISPLAY_ON0x29//aktywuje wyświetlanie
#define COLUMN_ADDR0x2A//określia obszar zapisu do pamięci danych dla y
//Parametr_1: adres początkowy; Parametr_2: adres końcowy;
#define PAGE_ADDR0x2B//określia obszar zapisu do pamięci danych dla x
//Parametr_1: adres początkowy; Parametr_2: adres końcowy;
#define MEM_WRITE0x2C//rozpoczyna początek zapisu do pamięci danych
#definePARTIAL_AREA0x30//definiuje obszar wyświetlania w trybie cześciowym
//Parametr_1: wiersz początkowy; Parametr_2: wiersz końcowy;
#define MEM_CONTROL0x36//definiuje kierunek odczytu / zapisu pamięci danych
//Parametr: MY,MX,MV,ML,RGB,MH,x,x
#define IDLE_OFF0x38//wyprowadza wyświetlacz z trybu oczekiwania
#define IDLE_ON0x39//wprowadza wyświetlacz w tryb oczekiwania, wyrażanie kolorów jest zmiejszone
#define PALETTE0x3A//definiuje format danych RGB
//Parametr: 0x02 - 8bit ; 0x03 - 12bit ; 0x05 - 16 bit
//----------------------------------------------------------------------------------------


//definicja podstawowych kolorów
#if ( USE_PALETTE == 0x05)
#define black0x0000
#define white0xFFFF
#define red0xF800
#define green0x07E0
#define blue0x001F
#define brown0x6180
#define cyan0x07FF
#define lime0x97A0
#define orange0xFD20
#define purple0xB81F
#define grey0xDEBA
#define pink0xFE19
#define yellow0xFFE0
#elif ( USE_PALETTE == 0x02)
#define black0x00
#define white0xFF
#define red0xE0
#define green0x1C
#define blue0x03
#define brown0xD0
#define cyan0x1D
#define lime0xBC
#define orange0xF8
#define purple0xC1
#define grey0xB5
#define pink0xF7
#define yellow0xFC
#endif
//----------------------------------------------------------------------------------------


// deklaracje funkcji
void Init_SPI (void);
void Init_Display (void);
void CLS_Display (uint16_t color);
void Text_Display(const char * str, uint8_t x, uint8_t y, uint16_t fontc, uint16_t backc, uint8_t scale);
void Int_Display(int val, uint8_t x, uint8_t y, uint16_t fontc, uint16_t backc, uint8_t scale);
void Img_Display(char *filename, uint8_t x, uint8_t y);
void Line_Display(uint8_t x1, uint8_t y1, uint8_t x2, uint8_t y2, uint16_t color);
void Circle_Display(uint8_t x0, uint8_t y0, uint8_t radius, uint16_t color);
void Draw_Display(uint8_t x0, uint8_t y0, uint8_t x1, uint8_t y1, uint16_t color);
//----------------------------------------------------------------------------------------
#endif /* DISPLAY_H_ */[/syntax]
Widzę, że syntax coś niepoprawnie wyrównuje niektóre wartości.

font.c -nasza podstawowa czcionka
[syntax=c]//-----------------------------------------------------------------------------------------------------------
// *** Obsługa kolorowego wyświetlaczy TFT 132x176 LPH9157-2 ***
//
//Biblioteka do obsługi kolorowego wyświetlaca TFT z telefonu Siemens C75 i podobne.
//Umożliwia wyświetlanie bitmap 24 bitowych RGB888 oraz 16 bitowych RGB565 z karty SD.
//
//
// Data : październik 2015
// Autor : Anonimowy
//----------------------------------------------------------------------------------------------------------

#ifndef DISPLAY_FONT_H_
#define DISPLAY_FONT_H_

const char font [] [8] PROGMEM = {
{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00},//SPACJA
{0x00,0x00,0x06,0x5f,0x06,0x00,0x00,0x00},// !
{0x00,0x07,0x03,0x00,0x07,0x03,0x00,0x00},// "
{0x00,0x24,0x7e,0x24,0x7e,0x24,0x00,0x00},// #
{0x00,0x24,0x2b,0x6a,0x12,0x00,0x00,0x00},// $
{0x00,0x63,0x13,0x08,0x64,0x63,0x00,0x00},// %
{0x00,0x36,0x49,0x56,0x20,0x50,0x00,0x00},// &
{0x00,0x00,0x07,0x03,0x00,0x00,0x00,0x00},// '
{0x00,0x00,0x3e,0x41,0x00,0x00,0x00,0x00},// (
{0x00,0x00,0x41,0x3e,0x00,0x00,0x00,0x00},// )
{0x00,0x08,0x3e,0x1c,0x3e,0x08,0x00,0x00},// *
{0x00,0x08,0x08,0x3e,0x08,0x08,0x00,0x00},// +
{0x00,0x00,0xe0,0x60,0x00,0x00,0x00,0x00},// ,
{0x00,0x08,0x08,0x08,0x08,0x08,0x00,0x00},// -
{0x00,0x00,0x60,0x60,0x00,0x00,0x00,0x00},// .
{0x00,0x20,0x10,0x08,0x04,0x02,0x00,0x00},// /
{0x00,0x3e,0x51,0x49,0x45,0x3e,0x00,0x00},// 0
{0x00,0x00,0x42,0x7f,0x40,0x00,0x00,0x00},// 1
{0x00,0x62,0x51,0x49,0x49,0x46,0x00,0x00},// 2
{0x00,0x22,0x49,0x49,0x49,0x36,0x00,0x00},// 3
{0x00,0x18,0x14,0x12,0x7f,0x10,0x00,0x00},// 4
{0x00,0x2f,0x49,0x49,0x49,0x31,0x00,0x00},// 5
{0x00,0x3c,0x4a,0x49,0x49,0x30,0x00,0x00},// 6
{0x00,0x01,0x71,0x09,0x05,0x03,0x00,0x00},// 7
{0x00,0x36,0x49,0x49,0x49,0x36,0x00,0x00},// 8
{0x00,0x06,0x49,0x49,0x29,0x1e,0x00,0x00},// 9
{0x00,0x00,0x6c,0x6c,0x00,0x00,0x00,0x00},// :
{0x00,0x00,0xec,0x6c,0x00,0x00,0x00,0x00},// ;
{0x00,0x08,0x14,0x22,0x41,0x00,0x00,0x00},// <
{0x00,0x24,0x24,0x24,0x24,0x24,0x00,0x00},// =
{0x00,0x00,0x41,0x22,0x14,0x08,0x00,0x00},// >
{0x00,0x02,0x01,0x59,0x09,0x06,0x00,0x00},// ?
{0x00,0x3e,0x41,0x5d,0x55,0x1e,0x00,0x00},// @
{0x00,0x7e,0x11,0x11,0x11,0x7e,0x00,0x00},// A
{0x00,0x7f,0x49,0x49,0x49,0x36,0x00,0x00},// B
{0x00,0x3e,0x41,0x41,0x41,0x22,0x00,0x00},// C
{0x00,0x7f,0x41,0x41,0x41,0x3e,0x00,0x00},// D
{0x00,0x7f,0x49,0x49,0x49,0x41,0x00,0x00},// E
{0x00,0x7f,0x09,0x09,0x09,0x01,0x00,0x00},// F
{0x00,0x3e,0x41,0x49,0x49,0x7a,0x00,0x00},// G
{0x00,0x7f,0x08,0x08,0x08,0x7f,0x00,0x00},// H
{0x00,0x00,0x41,0x7f,0x41,0x00,0x00,0x00},// I
{0x00,0x30,0x40,0x40,0x40,0x3f,0x00,0x00},// J
{0x00,0x7f,0x08,0x14,0x22,0x41,0x00,0x00},// K
{0x00,0x7f,0x40,0x40,0x40,0x40,0x00,0x00},// L
{0x00,0x7f,0x02,0x04,0x02,0x7f,0x00,0x00},// M
{0x00,0x7f,0x02,0x04,0x08,0x7f,0x00,0x00},// N
{0x00,0x3e,0x41,0x41,0x41,0x3e,0x00,0x00},// O
{0x00,0x7f,0x09,0x09,0x09,0x06,0x00,0x00},// P
{0x00,0x3e,0x41,0x51,0x21,0x5e,0x00,0x00},// Q
{0x00,0x7f,0x09,0x09,0x19,0x66,0x00,0x00},// R
{0x00,0x26,0x49,0x49,0x49,0x32,0x00,0x00},// S
{0x00,0x01,0x01,0x7f,0x01,0x01,0x00,0x00},// T
{0x00,0x3f,0x40,0x40,0x40,0x3f,0x00,0x00},// U
{0x00,0x1f,0x20,0x40,0x20,0x1f,0x00,0x00},// V
{0x00,0x3f,0x40,0x3c,0x40,0x3f,0x00,0x00},// W
{0x00,0x63,0x14,0x08,0x14,0x63,0x00,0x00},// X
{0x00,0x07,0x08,0x70,0x08,0x07,0x00,0x00},// Y
{0x00,0x71,0x49,0x45,0x43,0x00,0x00,0x00},// Z
{0x00,0x00,0x7f,0x41,0x41,0x00,0x00,0x00},// [
{0x00,0x02,0x04,0x08,0x10,0x20,0x00,0x00},// \ //
{0x00,0x00,0x41,0x41,0x7f,0x00,0x00,0x00},// ]
{0x00,0x04,0x02,0x01,0x02,0x04,0x00,0x00},// ^
{0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80},// _
{0x00,0x00,0x03,0x07,0x00,0x00,0x00,0x00},// `
{0x00,0x20,0x54,0x54,0x54,0x78,0x00,0x00},// a
{0x00,0x7f,0x44,0x44,0x44,0x38,0x00,0x00},// b
{0x00,0x38,0x44,0x44,0x44,0x28,0x00,0x00},// c
{0x00,0x38,0x44,0x44,0x44,0x7f,0x00,0x00},// d
{0x00,0x38,0x54,0x54,0x54,0x08,0x00,0x00},// e
{0x00,0x08,0x7e,0x09,0x09,0x00,0x00,0x00},// f
{0x00,0x18,0xa4,0xa4,0xa4,0x7c,0x00,0x00},// g
{0x00,0x7f,0x04,0x04,0x78,0x00,0x00,0x00},// h
{0x00,0x00,0x00,0x7d,0x40,0x00,0x00,0x00},// i
{0x00,0x40,0x80,0x84,0x7d,0x00,0x00,0x00},// j
{0x00,0x7f,0x10,0x28,0x44,0x00,0x00,0x00},// k
{0x00,0x00,0x00,0x7f,0x40,0x00,0x00,0x00},// l
{0x00,0x7c,0x04,0x18,0x04,0x78,0x00,0x00},// m
{0x00,0x7c,0x04,0x04,0x78,0x00,0x00,0x00},// n
{0x00,0x38,0x44,0x44,0x44,0x38,0x00,0x00},// o
{0x00,0xfc,0x44,0x44,0x44,0x38,0x00,0x00},// p
{0x00,0x38,0x44,0x44,0x44,0xfc,0x00,0x00},// q
{0x00,0x44,0x78,0x44,0x04,0x08,0x00,0x00},// r
{0x00,0x08,0x54,0x54,0x54,0x20,0x00,0x00},// s
{0x00,0x04,0x3e,0x44,0x24,0x00,0x00,0x00},// t
{0x00,0x3c,0x40,0x20,0x7c,0x00,0x00,0x00},// u
{0x00,0x1c,0x20,0x40,0x20,0x1c,0x00,0x00},// v
{0x00,0x3c,0x60,0x30,0x60,0x3c,0x00,0x00},// w
{0x00,0x6c,0x10,0x10,0x6c,0x00,0x00,0x00},// x
{0x00,0x9c,0xa0,0x60,0x3c,0x00,0x00,0x00},// y
{0x00,0x64,0x54,0x54,0x4c,0x00,0x00,0x00},// z
{0x00,0x08,0x3e,0x41,0x41,0x00,0x00,0x00},// {
{0x00,0x00,0x00,0x77,0x00,0x00,0x00,0x00},// |
{0x00,0x00,0x41,0x41,0x3e,0x08,0x00,0x00},// }
{0x00,0x02,0x01,0x02,0x01,0x00,0x00,0x00} // ~
};

#endif /* DISPLAY_FONT_H_ */[/syntax]

No i w końcu najważniejsze:
display.c
[syntax=c]//-----------------------------------------------------------------------------------------------------------
// *** Obsługa kolorowego wyświetlaczy TFT 132x176 LPH9157-2 ***
//
//Biblioteka do obsługi kolorowego wyświetlaca TFT z telefonu Siemens C75 i podobne.
//Umożliwia wyświetlanie bitmap 24 bitowych RGB888 oraz 16 bitowych RGB565 z karty SD.
//
//
// Data : październik 2015
// Autor : Anonimowy
//----------------------------------------------------------------------------------------------------------
#include <avr/io.h>
#include <util/delay.h>
#include <avr/pgmspace.h>
#include <stdio.h>
#include <stdlib.h>

#include "display.h"
#include "font.h"
#include "../PetitFS/diskio.h"
#include "../PetitFS/pff.h"

//********************* FUNKCJE WEWNĘTRZNE *********************

//----------------------------------------------------------------------------------------
//
//Wysłanie komendy przez sprzętowy SPI
//
//----------------------------------------------------------------------------------------
static void send_cmd (uint8_t cmd){
RS_PORT &= ~(1<<RS);//RS -komenda
SPDR = cmd;//załaduj bajt do rejestru
while(!(SPSR & (1<<SPIF)));//czekaj na koniec wysyłania
RS_PORT |= (1<<RS);//RS -dana -dla przyśpieszenia ładowania danych
}

//----------------------------------------------------------------------------------------
//
// Wysłanie danej przez sprzętowy SPI
//
//----------------------------------------------------------------------------------------
static inline void send_data (uint8_t data){
SPDR = data;//załaduj bajt do rejestru
while(!(SPSR & (1<<SPIF)));//czekaj na koniec wysyłania
}

//----------------------------------------------------------------------------------------
//
//Ustawienie pola zapisu do pamięci RAM
//
//----------------------------------------------------------------------------------------
static void set_field (uint8_t startX, uint8_t stopX, uint8_t startY, uint8_t stopY){
send_cmd (COLUMN_ADDR);//ustaw zakres zapisu do RAM dla y
send_data (startY);
send_data (stopY);
send_cmd (PAGE_ADDR);//ustaw zakres zapisu do RAM dla x
send_data (startX);
send_data (stopX);
send_cmd (MEM_WRITE);//rozpocznij zapis do RAM
}

//----------------------------------------------------------------------------------------
//
//Aktywacja pojedynczego pixela
//
//----------------------------------------------------------------------------------------
static void set_pixel(uint8_t x, uint8_t y, uint16_t color){
CS_ON;
set_field (x, x, y, y);
#if USE_PALETTE == 0x05//jeśli paleta 16 bitów
send_data (color >> 8);//wyślij pierwszy bajt koloru
send_data (color);//wyślij drugi bajt koloru
#elif USE_PALETTE == 0x02//jeśli paleta 8 bitów
send_data (color);//wyślij bajt koloru
#endif
CS_OFF;
}

//----------------------------------------------------------------------------------------
//
//Wysyłanie pojedyńczego znaku
//
//----------------------------------------------------------------------------------------
static void send_char (char znak, uint16_t fontc, uint16_t backc, uint8_t scale){
uint8_t i, cnt,cnt_2, cnt_3, pixel;

for (i = 0 ; i < 8 ; i++){
pixel = pgm_read_byte(&font[(znak-32)][i]);//pobierz bajt znaku
for (cnt_2 = 0; cnt_2 < scale; cnt_2++){//skalowanie czcionki -kolumny
for (cnt = 0; cnt < 8; cnt++){
for (cnt_3 = 0; cnt_3 < scale; cnt_3++){//skalowanie czcionki -wiersze
if (pixel & (1 << cnt) ){//jesli pixel aktywny
#if USE_PALETTE == 0x05//jeśli paleta 16 bitów
send_data (fontc >> 8);//wyślij pierwszy bajt koloru
send_data (fontc);//wyślij drugi bajt koloru
#elif USE_PALETTE == 0x02//jeśli paleta 8 bitów
send_data (fontc);//wyślij bajt koloru
#endif
}
else{//jeśli pixel nieaktywny
#if USE_PALETTE == 0x05//jeśli paleta 16 bitów
send_data (backc >> 8);//wyślij pierwszy bajt koloru
send_data (backc );//wyślij drugi bajt koloru
#elif USE_PALETTE == 0x02//jeśli paleta 8 bitów
send_data (backc);//wyślij bajt koloru
#endif
}
}
}
}
}
}

#if USE_IMG_DISPLAY == 1
//----------------------------------------------------------------------------------------
//
// Ładowanie zdjęcia 16 bitowego
//
//----------------------------------------------------------------------------------------
void IMG_16(char * bufor, uint32_t * offset, uint16_t buf_size){
BYTE res;
WORD len;
uint16_t cnt;

res = pf_lseek(*offset);//ustaw wskaźnik pliku na początek tablicy pikseli
if (!res){
do{
res = pf_read(bufor, buf_size, &len);//pobierz dane do buforu
CS_ON;
for (cnt = 0; cnt < len; cnt +=2){//wyślij zawartośc buforu do pamięci wyświetlacza
send_data(*(bufor + cnt + 1));
send_data(*(bufor + cnt));
}
CS_OFF;
}while ((len == buf_size) && !res);//zakończ jeśli koniec pliku lub błąd odczytu pliku
}

}

//----------------------------------------------------------------------------------------
//
// Ładowanie zdjęcia 24 bitowego
//
//----------------------------------------------------------------------------------------
void IMG_24(char * bufor, uint32_t * offset, uint16_t buf_size){
BYTE res;
WORD len;
uint16_t cnt;
uint8_t R, G, B;

res = pf_lseek(*offset);//ustaw wskaźnik pliku na początek tablicy pikseli
while ( buf_size % 3) buf_size--;//rozmiar buforu musi byc podzielny przez 3
if (!res){
do{
res = pf_read(bufor, buf_size, &len);//pobierz dane do buforu
CS_ON;
for (cnt = 0; cnt < len; cnt +=3){
R = (*(bufor + cnt + 2));//pobierz trzy składowe koloru
G = (*(bufor + cnt + 1));
B = (*(bufor + cnt));
send_data((R & 0xF8) | (G >>5));//zamień na RGB565 oraz wyślij do pamięci wyświetlacza
send_data(((G << 3) & 0xE0) | (B >> 3));
}
CS_OFF;
}while ((len == buf_size) && !res);//zakończ jeśli koniec pliku lub błąd odczytu pliku
}
}
#endif

//**************************************************************


//****************** FUNKCJE DLA UŻYTKOWNIKA *******************
//----------------------------------------------------------------------------------------
//
//Inicjalizacja SPI
//
//----------------------------------------------------------------------------------------
void Init_SPI (void){
SPI_DDR |= (1<<MOSI) | (1<<SCK) | (1<<CS);//piny SPI jako wyjście
SPCR |= (1<<SPE) | (1<<MSTR);//SPI ON, tryb master, CLK/4
SPSR |= (1<<SPI2X);//CLK/2 -podwojona prędkośc
}

//----------------------------------------------------------------------------------------
//
//Inicjalizacja wyświetlacza
//
//----------------------------------------------------------------------------------------
void Init_Display (void){
CS_ON;
RS_DDR |= (1<<RS);//RS jako wyjście
#ifdef RST//jeśli korzystamy z sprzętowego resetu
RST_DDR |= (1<<RST);//RST jako wyjście
RST_PORT &= ~(1<<RST);//impuls resetujący
_delay_us(20);//minimum 10us
RST_PORT |= (1<<RST);//koniec impulsu resetującego
#else//jeśli nie korzystamy z programowego resetu
send_cmd (SOFT_RST);//wykonaj reset sprzętowy
#endif
_delay_ms(120);//czas niezbędny do przywrócenia domyslnych wartości rejestrów
send_cmd (SLEEP_OUT);//wyjdź z trybu uśpienia
_delay_ms(5);//minimalny czas powrotu do stanu pracy
send_cmd (MEM_CONTROL);//kierunek odczytu / zapisu pamięci danych
send_data (USE_MEM_CONTROL);
send_cmd (PALETTE);//format danych RGB
send_data (USE_PALETTE);
#ifdef USE_SPARTIAL//jeśli tryb częściowy wyświetlaca
send_cmd (PARTIAL_AREA);//definiuj obszar trybu częściowego
send_data (USE_SPARTIAL);//wyślij adres początku trybu częściowego
send_data (USE_EPARTIAL);//wyślij adres końca trybu częściowego
send_cmd (PARTIAL_MODE);//włącz tryb częściowy
#endif
send_cmd (DISPLAY_ON);//aktywuj wyświetlanie
CS_OFF;
}

#if USE_CLS_DISPLAY == 1
//----------------------------------------------------------------------------------------
//
//Czyszczenie wyświetlacza
//
//----------------------------------------------------------------------------------------
void CLS_Display (uint16_t color){
uint16_t i;

CS_ON;
set_field (0, 175, 0, 131);//ustaw pole robocze -cały wyświetlacz
for (i = 0; i < 23232 ; i++){
#if USE_PALETTE == 0x05//jeśli paleta 16 bitów
send_data (color >> 8);//wyślij pierwszy bajt koloru
send_data (color);//wyślij drugi bajt koloru
#elif USE_PALETTE == 0x02//jeśli paleta 8 bitów
send_data (color);//wyślij bajt koloru
#endif
}
CS_OFF;
}
#endif

#if USE_TEXT_DISPLAY == 1
//----------------------------------------------------------------------------------------
//
//Wyśwetlanie napisu z pamięci programu
//
//----------------------------------------------------------------------------------------
void Text_Display(const char * str, uint8_t x, uint8_t y, uint16_t fontc, uint16_t backc, uint8_t scale ){
char znak;

CS_ON;
set_field (x, 175, y, (y + (8 * scale) - 1));//ustaw pole robocze
while ( (znak = pgm_read_byte(str++)) ){//pobierz znak z pamięci programu
send_char(znak, fontc, backc, scale);//wyświetl znak
}
send_cmd (LCD_NOP);//zakończ zapis do pamięci RAM
CS_OFF;
}
#endif

#if USE_INT_DISPLAY == 1
//----------------------------------------------------------------------------------------
//
//Wyśwetlanie zmiennej
//
//----------------------------------------------------------------------------------------
void Int_Display(int val, uint8_t x, uint8_t y, uint16_t fontc, uint16_t backc, uint8_t scale ){
char buf[10], znak;
uint8_t i = 0;

itoa(val, buf, 10);
CS_ON;
set_field (x, 175, y, (y + (8 * scale) - 1));//ustaw pole robocze
while ( (znak = buf[i++]) ){//pobierz znak z pamięci programu
send_char(znak, fontc, backc, scale);//wyświetl znak
}
send_cmd (LCD_NOP);//zakończ zapis do pamięci RAM
CS_OFF;
}
#endif

#if USE_IMG_DISPLAY == 1
//----------------------------------------------------------------------------------------
//
//Wyświetlanie zdjęcia z karty SD
//
//----------------------------------------------------------------------------------------
void Img_Display(char *filename, uint8_t x, uint8_t y){
char bufor[IMG_BUF] ;
BYTE res, bitCount;
WORD len;
FATFS fs;
uint32_t offset, height, width;

res = pf_mount(&fs);//zamontuj system plików
if (!res){
res = pf_open(filename);//otwórz folder
if (!res){
res = pf_read(bufor, 29, &len);//odczytaj początek pliku -nagłówek
if (!res && len == 29){
if (bufor[0] == 'B' && bufor[1] == 'M' ){//sprawdź czy plikiem jest bitmapa
offset = ((ULONG)bufor[13] << 24) | ((ULONG)bufor[12] << 16) | ((ULONG)bufor[11] << 8) | ((ULONG)bufor[10]);
width = ((ULONG)bufor[21] << 24) | ((ULONG)bufor[20] << 16) | ((ULONG)bufor[19] << 8) | ((ULONG)bufor[18]);
height = ((ULONG)bufor[25] << 24) | ((ULONG)bufor[24] << 16) | ((ULONG)bufor[23] << 8) | ((ULONG)bufor[22]);
bitCount = bufor[28];
if ((width + y) <= 132 && (height + x) <= 176 && !(width % 4) ){
CS_ON;
set_field (x, (height -1 + x ), y, (width -1 + y )); //ustaw pole robocze
CS_OFF;
if (bitCount == 16){//jeśli bitmapa 16 bitowa
IMG_16(bufor, &offset, sizeof(bufor));
}else if (bitCount == 24) {//jeśli bitmapa 24 bitowa
IMG_24(bufor, &offset, sizeof(bufor));
}else Text_Display (PSTR("PALETTE ERROR"), 36, 112, red, white, 1);
}else Text_Display (PSTR("SIZE ERROR"), 48, 112, red, white, 1);
}else Text_Display (PSTR("BITMAP ERROR"), 40, 112, red, white, 1);
}else Text_Display (PSTR("READ ERROR"), 48, 112, red, white, 1);
}else Text_Display (PSTR("OPEN FILE ERROR"), 28, 112, red, white, 1);
}else Text_Display (PSTR("MOUNT ERROR"), 44, 112, red, white, 1);
pf_mount(NULL);
}
#endif

#if USE_DRAW_DISPLAY == 1
//----------------------------------------------------------------------------------------
//
//Rysowanie prostokątów
//
//----------------------------------------------------------------------------------------
void Draw_Display(uint8_t x0, uint8_t y0, uint8_t x1, uint8_t y1, uint16_t color){
uint16_t i;

CS_ON;
set_field (x0, x1, y0, y1);//ustaw pole robocze
for (i = 0; i < (((x1 - x0) + 1) * ((y1 - y0) + 1)) ; i++){
#if USE_PALETTE == 0x05//jeśli paleta 16 bitów
send_data (color >> 8);//wyślij pierwszy bajt koloru
send_data (color);//wyślij drugi bajt koloru
#elif USE_PALETTE == 0x02//jeśli paleta 8 bitów
send_data (color);//wyślij bajt koloru
#endif
}
CS_OFF;
}
#endif

#if USE_LINE_DISPLAY == 1
//----------------------------------------------------------------------------------------
//
//Rysowanie lini
//
//----------------------------------------------------------------------------------------
void Line_Display(uint8_t x1, uint8_t y1, uint8_t x2, uint8_t y2, uint16_t color){
int d, ai, bi;
uint8_t dx, dy;
int8_t xi, yi;

if (x1 < x2){// ustal kierunku rysowania dla x
xi = 1;
dx = x2 - x1;
}
else{
xi = -1;
dx = x1 - x2;
}
if (y1 < y2){// ustal kierunku rysowania dla y
yi = 1;
dy = y2 - y1;
}
else{
yi = -1;
dy = y1 - y2;
}
set_pixel(x1, y1, color);//aktywuj pierwszy piksel
if (dx > dy){// oś wiodąca OX
ai = (dy - dx) * 2;
bi = dy * 2;
d = bi - dx;
while (x1 != x2){// pętla dla x
if (d >= 0){
x1 += xi;
y1 += yi;
d += ai;
}
else{
d += bi;
x1 += xi;
}
set_pixel(x1, y1, color);//aktywuj pixel
}
}
else{// oś wiodąca OY
ai = (dx - dy) * 2;
bi = dx * 2;
d = bi - dy;
while (y1 != y2){// pętla dla y
if (d >= 0){
x1 += xi;
y1 += yi;
d += ai;
}
else{
d += bi;
y1 += yi;
}
set_pixel(x1, y1, color);//aktywuj pixel
}
}
}
#endif

#if USE_CIRCLE_DISPLAY == 1
//----------------------------------------------------------------------------------------
//
//Rysowanie okręgu
//
//----------------------------------------------------------------------------------------
void Circle_Display(uint8_t x0, uint8_t y0, uint8_t radius, uint16_t color){
uint8_t x = radius;
int y = 0;
int z = 1 - x;

while( y <= x ){
set_pixel( x + x0, y + y0, color);//aktywuj pixel
set_pixel( y + x0, x + y0, color);//aktywuj pixel
set_pixel(-x + x0, y + y0, color);//aktywuj pixel
set_pixel(-y + x0, x + y0, color);//aktywuj pixel
set_pixel(-x + x0, -y + y0, color);//aktywuj pixel
set_pixel(-y + x0, -x + y0, color);//aktywuj pixel
set_pixel( x + x0, -y + y0, color);//aktywuj pixel
set_pixel( y + x0, -x + y0, color);//aktywuj pixel
y++;
if (z<=0){
z += 2 * y + 1;
}
else{
x--;
z += 2 * (y - x) + 1;
}
}
}
#endif[/syntax]

Jak można zauważyć, w bibliotece wykorzystuję bibliotekę PetitFS, przystosowaną do tego celu. Tam w pliku diskio.h ustawiamy podłączenie pinu CS karty pamięci:
[syntax=c]//Ustawienie pinu CS karty SD
#define CS_SDPD5
#define SD_DDRDDRD
#define SD_PORTPORTD
/*---------------------------------------*/[/syntax]
Cała biblioteka lekkimi zmianami w załączniku wraz z moją biblioteką do obsługi LCD.

Jak widać w pliku display.h mamy możliwość włączania/wyłączania z kompilacji pewnych funkcji. A co dostajemy?
-Możliwość wyświetlenie zmiennej jako liczby dziesiętnej w dowolnym miejscu wyświetlacza, wraz z skalowaniem czcionki,
-Możliwość wyświetlenia tekstu z pamięci programu w dowolnym miejscu wyświetlacza, wraz z skalowaniem czcionki,
-Możliwość czyszczenia wyświetlacza dowolnym kolorem,
-Możliwość rysowania dowolnej linii według podanych współrzędnych początku i końca,
-Możliwość rysowania prostokątów według podanych współrzędnych dwóch rogów,
-Możliwość rysowania okręgów według podanych współrzędnych środka oraz promienia,
-Możliwość wyświetlania bitmap 16 bitowych RGB565 oraz 24 bitowych RGB888 prosto z karty SD w dowolnym miejscu wyświetlacza.

Te funkcje wystarczą nam, do stworzenia naprawdę dużej ilości efektów.

W tym samym pliku mamy jeszcze kilka ustawień, są stosowne komentarze.

Fajnie, biblioteka jest ale. No właśnie trzeba było iść na pewne kompromisy:
-Zdecydowałem się na wykorzystanie jedynie sprzętowego SPI z powodu prędkości. Jeśli ktoś chce, nie jest problemem zmiana na SPI programowe
Więcej ograniczeń jest, jeśli chodzi o wyświetlanie bitmap:
-Rozmiar bitmapy nie może przekroczyć 176x132 piksele
-Obsługiwane bitmapy 16 bitów są w RGB565, nie windowsowy RGB555
-Z powodu sposobu mapowania pamięci bitmapy na kartę muszą być ładowane obrócone o 90 stopni w lewo
-Wysokość bitmapy (czyli po obróceniu o 90 stopni szerokość) musi być podzielna przez 4. Wynika to z struktury pliku, a chciałem aby funkcja działała możliwie szybko.

Wypisane są wszystkie przetestowane przeze mnie komendy sterujące, nie wszystkie wykorzystuję w bibliotece, jednak opisałem je, jeśli ktoś chciałby je wykorzystać.
Wyświetlacz obsługuję paletę 8 bitów, 12 bitów i 16 bitów. Biblioteka umożliwia korzystanie jedynie z 8 i 16 bitów, przy czym bitmapy wyświetlać można jedynie w trybie 16 bitowym.

Myślę, że przyda się również przykład pliku main.c, aby nie było niedomówień:
[syntax=c]/*
* main.c
*
* Created on: 1 paź 2015
* Author: Anonimowy
*/
#include <avr/io.h>
#include <util/delay.h>
#include <avr/pgmspace.h>


#include "DISPLAY/display.h"
#include "PetitFS/diskio.h"
#include "PetitFS/pff.h"


int main(void) {
BYTE ress;
char file_name[] = "bitmapa.bmp";

Init_SPI();
ress = disk_initialize();
Init_Display();

CLS_Display(black);
Text_Display (PSTR("ATNEL"), 8, 20, white, black, 2);
Draw_Display(25, 56, 35, 75, green);
Circle_Display(88, 66, 55, yellow);
Line_Display(88, 66, 88, 30, orange);
_delay_ms(3000);
if (!ress){
Img_Display(file_name,0,0);
}
while(1){

}

}[/syntax]

Jak widać, proste jak drut :D

Teraz kilka słów podsumowania:
Od czasu gdy zakupiłem BB minął zaledwie miesiąc, świadczy to o tym, jak szybko ta książka uczy. Pomogło również to, że liznąłem w życiu już kilka różnych języków. Nie prawdą jest to co mówią, że trudno jest przejść z bascom na C. Fakt, pewne przyzwyczajenia pozostają i może są jakieś błędy w kodzie, dlatego proszę o wyrozumiałość, w C piszę bardzo krótko.
Jedno jest pewnie, napisanie tej biblioteki wiele mnie nauczyło, pomogło rozumieć wskaźniki, podział na pliki i zastosowanie tablicy wielowymiarowej (w bascomie tego nie miałem :oops: ).

No i na koniec, pragnąc dogonić wzór, efekty.
Mam nadzieję, że Pan Mirek nie obrazi się, że kopiowałem jego efekty oraz, że wykorzystałem jego wizerunek -to dla dobra nauki :lol:
iframe

Testy wykonywane na Atmega644, kwarc 17,720MHz.
Niestety nie udało mi się uzyskać ładnej animacji kota, mimo ładowania tylko małej ramki z miejscem, które ulega zmianie. Ładowanie z karty SD jest za wolne, może moja funkcja ładowania grafiki jest jakaś ociężała, może Pan Mirek ładował to z pamięci programu -nie wiem.

Niemniej, gdyby kogoś interesowało rysowanie linii, okręgów, prostokątów jeden po drugim jest programowo opóźniane dla efektów, funkcje z biblioteki działają stosunkowo szybko.

Statystyki: Napisane przez anonimowy — 16 paź 2015, o 19:41

]]>