ATNEL tech-forum

Re: SSD1289 inicjalizacja szum

2014-04-30T17:18:09+01:00

Z problemem się już uporałem, a mianowicie chodziło o PORTB, którego piny od 4 do 7 są wykorzystywane przez JTAG. Wystarczyło go wyłączyć i wszystko działa bez zarzutu. Za pewne każdy program który wgrywałem był w porządku, tylko nie możliwe było wysterowanie tych pinów.

Mimo wszystko bardzo wszystkim dziękuję

Statystyki: Napisane przez atmel — 30 kwi 2014, o 17:18

Re: SSD1289 inicjalizacja szum

2014-04-28T20:50:53+01:00

Zdaje się, że jest to jednak sterownik SSD1289, gdyż zakupiłem go na tej aukcji: http://allegro.pl/promocja-lcd-3-2-ssd1 ... 67493.html

Jednak do końca sam nie jestem przekonany, czy nie zaszła jakaś pomyłka przy wysyłce i nie otrzymałem ILI9320, który w sumie wygląda identycznie...

Jeśli dobrze odczytałem sygnaturę to wynosi ona 0x7989 , co to takiego?

Statystyki: Napisane przez atmel — 28 kwi 2014, o 20:50

Re: SSD1289 inicjalizacja szum

2014-04-28T09:04:04+01:00

Mscichu napisał(a):

Kolega mesho podesłał mi swojego czasu działający projekt, wstawię dla potomności, mam nadzieję, że nie będzie krzyczał

Nie mam za co się obrażać, już od dawna ten działający projekt jest też na moim blogu.
http://atmegan.blogspot.com/2014/02/obsuga-hy-320-ssd1289.html
Jest tam parę zaleceń ode mnie, polecam sprawdzić

@atmel
Sprawdź dokładnie czy to ten sterownik. Jeśli kupiłeś taki sam wyświetlacz jak mój (HY-320), jest on w wersjach ze sterownikiem SSD1289 oraz ILI9320, gdzie te moje biblioteki nie podpasują do tego drugiego. Skoro są te szumy to jak kolega Janadamis napisał, coś musi być z dalszymi funkcjami, z SSD1289 działają więc mniemam że masz inny sterownik.

Statystyki: Napisane przez mesho — 28 kwi 2014, o 09:04

Re: SSD1289 inicjalizacja szum

2014-04-28T07:31:27+01:00

A czy na pewno jest to ten sterownik? Widziałem jeszcze SSD1206 i inne, ewentualnie podłączenie wyświetlacza?

Statystyki: Napisane przez Mscichu — 28 kwi 2014, o 07:31

Re: SSD1289 inicjalizacja szum

2014-04-27T23:56:16+01:00

Niestety zamieniając te biblioteki w dalszym ciągu problem pozostaje nierozwiązany...

Statystyki: Napisane przez atmel — 27 kwi 2014, o 23:56

Re: SSD1289 inicjalizacja szum

2014-04-27T21:43:02+01:00

Kolega mesho podesłał mi swojego czasu działający projekt, wstawię dla potomności, mam nadzieję, że nie będzie krzyczał

Statystyki: Napisane przez Mscichu — 27 kwi 2014, o 21:43

Re: SSD1289 inicjalizacja szum

2014-04-27T19:30:50+01:00

Chciałbym odświeżyć temat, gdyż mam niestety identyczny problem mimo to iż zaktualizowałem swoje biblioteki zgodnie z tymi umieszczonymi na stronie https://github.com/gpittarelli/avr-ssd1 ... ster/TFT.c.

Używam ATxmega128A3U taktowanego w sumie dowolnym zegarem jak to na xmega przystało

Bardzo proszę o pomoc w tej sprawie bo już od przeszło tygodnia ręce mi opadają

Biblioteka:

[syntax=c]#include "TFT.hpp"
#include "pins.hpp"

void TFT_write_command(uint16_t command)
{
LCD_STER.OUTCLR = LCD_CS;
LCD_STER.OUTCLR = LCD_RS;
LCD_DATA_H.OUT = command>>8;
LCD_DATA_L.OUT = command;
LCD_STER.OUTCLR = LCD_WR;
LCD_STER.OUTSET = LCD_WR;
LCD_STER.OUTSET = LCD_CS;
}

void TFT_write_data(uint16_t data)
{
LCD_STER.OUTCLR = LCD_CS;
LCD_STER.OUTSET = LCD_RS;
LCD_DATA_H.OUT = data>>8;
LCD_DATA_L.OUT = data;
LCD_STER.OUTCLR = LCD_WR;
LCD_STER.OUTSET = LCD_WR;
LCD_STER.OUTSET = LCD_CS;
}

void TFT_write_command_data(uint16_t command, uint16_t data)
{
TFT_write_command(command);
TFT_write_data(data);
}

void LCD_Send_SSD1298(uint16_t command, uint16_t data)
{
TFT_write_command(command);
TFT_write_data(data);
}

void TFT_write_address(uint16_t x1, uint16_t y1, uint16_t x2, uint16_t y2)
{
TFT_write_command_data(0x0044, (x2<<8) + x1);
TFT_write_command_data(0x0045, y1);
TFT_write_command_data(0x0046, y2);
TFT_write_command_data(0x004e, x1);
TFT_write_command_data(0x004f, y1);
TFT_write_command(0x0022);
}

void TFT_fill(uint16_t color)
{
TFT_write_address(0, 0, 239, 319);
TFT_write_data(color);
for(uint32_t i = 0; i <= 0x9600; i++) {
LCD_STER.OUTCLR = LCD_CS;
LCD_STER.OUTCLR = LCD_WR;
LCD_STER.OUTSET = LCD_WR;
LCD_STER.OUTCLR = LCD_WR;
LCD_STER.OUTSET = LCD_WR;
LCD_STER.OUTSET = LCD_CS;
}
}

void TFT_draw_box(uint16_t x1, uint16_t y1, uint16_t x2, uint16_t y2, uint16_t color)
{
uint16_t dx = x2 - x1 + 2, j;
LCD_STER.OUTCLR = LCD_CS;
TFT_write_address(x1, y1, x2, y2);
TFT_write_data(color);
y2 = (y2 - y1) + 2;
while (--y2) {
j = dx;
while (--j) {
LCD_STER.OUTCLR = LCD_WR;
LCD_STER.OUTSET = LCD_WR;
}
}
LCD_STER.OUTSET = LCD_CS;
}

void TFT_box_outline(uint16_t x1, uint16_t y1, uint16_t x2, uint16_t y2, uint16_t width, uint16_t color)
{
--width;
TFT_draw_box(x1, y1, x2, y1 + width, color);
TFT_draw_box(x1, y1 + width, x1 + width, y2 - width, color);
TFT_draw_box(x2 - width, y1 + width, x2, y2 - width, color);
TFT_draw_box(x1, y2 - width, x2, y2, color);
}

void TFT_dot(uint16_t x, uint16_t y, uint16_t color)
{
LCD_STER.OUTCLR = LCD_CS;
TFT_write_address(x, y, x, y);
TFT_write_data(color);
LCD_STER.OUTSET = LCD_CS;
}

uint16_t TFT_init(void)
{
LCD_DATA_L_DIR = 0xFF;
LCD_DATA_H_DIR = 0xFF;
LCD_DATA_L.OUT = 0x00;
LCD_DATA_H.OUT = 0x00;
LCD_STER_DIR |= LCD_CS|LCD_RD|LCD_WR|LCD_RS|LCD_RESET;
LCD_STER.OUTSET = LCD_CS|LCD_RD|LCD_WR|LCD_RS|LCD_RESET;
//_delay_ms(5);
LCD_STER.OUTCLR = LCD_CS;
LCD_STER.OUTCLR = LCD_RESET;
_delay_ms(20);
LCD_STER.OUTSET = LCD_RESET;
_delay_ms(20);

LCD_Send_SSD1298(0x0000, 0x0001);_delay_ms(15);
LCD_Send_SSD1298(0x0003, 0xA8A4);
LCD_Send_SSD1298(0x000C, 0x0000);
LCD_Send_SSD1298(0x000D, 0x080C);
LCD_Send_SSD1298(0x000E, 0x2B00);
LCD_Send_SSD1298(0x001E, 0x00B8);_delay_ms(15);//0x00B70x00B0
LCD_Send_SSD1298(0x0001, 0x2B3F);
LCD_Send_SSD1298(0x0002, 0x0600);
LCD_Send_SSD1298(0x0010, 0x0000);_delay_ms(30);
LCD_Send_SSD1298(0x0011, 0x4030);_delay_ms(20);//0x6070
//LCD_Send_SSD1298(0x0007, 0b0001100100110011);//0x0233
LCD_Send_SSD1298(0x0005, 0x0000);
LCD_Send_SSD1298(0x0006, 0x0000);
LCD_Send_SSD1298(0x0016, 0xEF1C);
LCD_Send_SSD1298(0x0017, 0x0003);
LCD_Send_SSD1298(0x0007, 0b0001100100110011);//0x0233
LCD_Send_SSD1298(0x000B, 0x0000);
LCD_Send_SSD1298(0x000F, 0x0000);_delay_ms(20);
LCD_Send_SSD1298(0x0041, 0x0000);
LCD_Send_SSD1298(0x0042, 0x0000);
LCD_Send_SSD1298(0x0048, 0x0000);
LCD_Send_SSD1298(0x0049, 0x013F);
LCD_Send_SSD1298(0x004B, 0x0000);_delay_ms(30);
LCD_Send_SSD1298(0x0044, 0xEF00);
LCD_Send_SSD1298(0x0045, 0x0000);
LCD_Send_SSD1298(0x0046, 0x013F);
LCD_Send_SSD1298(0x0030, 0x0707);
LCD_Send_SSD1298(0x0031, 0x0204);
LCD_Send_SSD1298(0x0032, 0x0204);
LCD_Send_SSD1298(0x0033, 0x0502);
LCD_Send_SSD1298(0x0034, 0x0507);
LCD_Send_SSD1298(0x0035, 0x0204);
LCD_Send_SSD1298(0x0036, 0x0204);
LCD_Send_SSD1298(0x0037, 0x0502);
LCD_Send_SSD1298(0x003A, 0x0302);
LCD_Send_SSD1298(0x003B, 0x0302);
LCD_Send_SSD1298(0x0023, 0x0000);
LCD_Send_SSD1298(0x0024, 0x0000);
LCD_Send_SSD1298(0x0025, 0x8000);

LCD_Send_SSD1298(0x004f, 0x0000);
LCD_Send_SSD1298(0x004e, 0x0000);
TFT_write_command(0x0022);

LCD_STER.OUTSET = LCD_CS;
}

void TFT_char(const uint8_t *font, uint8_t ch, uint16_t x, uint16_t y, uint16_t fg_color, uint16_t bg_color, uint16_t width, uint16_t height)
{
uint16_t j, k;
const uint8_t *bmp_addr = font + ((ch - ' ') * height * (width / 8));
uint8_t bmp_byte = 0, pixel_mask = 0x80;
uint8_t bit_set = 0;
LCD_STER.OUTCLR = LCD_CS;
TFT_write_address(x, y, x + width - 1, y + height - 1);
k = 0;
while (height--)
for (j = width; j; --j) {
if (!(k % 8)) {
bmp_byte = pgm_read_byte(bmp_addr++);
pixel_mask = 0x80;
}
bit_set = bmp_byte & pixel_mask;
pixel_mask >>= 1;
++k;
if (bit_set)
TFT_write_data(fg_color);
else TFT_write_data(bg_color);
}
LCD_STER.OUTSET = LCD_CS;
}[/syntax]
Main:

[syntax=c]#include
#include "Osc.hpp"
#include "TFT.hpp"

int main(void)
{
//Osc32MHz();
//OscPLL(2);

TFT_init();
TFT_fill(0x001F);
TFT_draw_box(10, 20, 30, 40, 0x001F);

while (true);
}[/syntax]

Dodam jeszcze, że dzieją się dość dziwne rzeczy z samą konfiguracją F_CPU, tzn. gdy domyślnie procesor taktowany jest 2MHz i takie też jest ustawienie F_CPU, wtedy na wyświetlaczu nie ma absolutnie nic, ale tylko kiedy zmienię F_CPU na 32000000 zaczyna migać, później są widoczne szumy jak u Kol. mesho, następnie poziome kolorowe linie, a na samym końcu ponownie losowy kolorowy szum. Dostosowując zegar do ustawień F_CPU w dalszym ciągu nie wyświetla się absolutnie nic...

Statystyki: Napisane przez atmel — 27 kwi 2014, o 19:30

Re: SSD1289 inicjalizacja szum

2014-02-02T12:09:10+01:00

Przy zakupie trzeba wygrzebać albo wypytać sprzedawcę, na jakim sterowniku jest ten wyświetlacz bo faktycznie HY-320 jest jak dobrze widzę w dwóch wersjach.

Statystyki: Napisane przez mesho — 2 lut 2014, o 12:09

Re: SSD1289 inicjalizacja szum

2014-02-01T22:10:18+01:00

Czy to jest na pewno kontroler SSD1289, widziałem na stronach sklepów te wyświetlacze (HY-320) z kontrolerem ILI9320.
A jeżeli dobrze pamiętam są one podobne ( kontrolery), ale jednak różnią się w wielu szczegółach.

Statystyki: Napisane przez krish — 1 lut 2014, o 22:10

Re: SSD1289 inicjalizacja szum

2014-02-01T22:04:19+01:00

Janadamis - i tu był pies pogrzebany! Znalazłem poprawne funkcje na stronie https://github.com/gpittarelli/avr-ssd1289/blob/master/TFT.c, szkoda że na nich nie zacząłem bazować, ale trudno grunt że udało się problem rozwikłać

Dziękuję za pomoc!

Statystyki: Napisane przez mesho — 1 lut 2014, o 22:04

Re: SSD1289 inicjalizacja szum

2014-02-01T21:26:34+01:00

Szumi bo ma szumieć każdy po inicjalizacji będzie tak szumiał te kolory to przypadkowe wartości w pamięci SRAM sterownika A skoro je widzisz to znaczy że inicjalizacja działa. Pisałeś że jak podasz funkcje testowe to tylko piksele w pierwszej linii się zmieniają? Czyli masz kłopot z tymi funkcjami. A dokłądnie to pewnie o funkcję ustalającą współrzędną.

Statystyki: Napisane przez Janadamis — 1 lut 2014, o 21:26

Re: SSD1289 inicjalizacja szum

2014-02-01T20:50:15+01:00

jak uruchomiłem test to w szumie można było "kwiatek" dostrzec

Statystyki: Napisane przez Mscichu — 1 lut 2014, o 20:50

Re: SSD1289 inicjalizacja szum

2014-02-01T19:40:40+01:00

Problem wciąż w toku rozkminiania, ale dzięki za sprawdzenie, w takim razie opcje wadliwego wyświetlacza czy połączeń będzie można wykluczyć, przynajmniej jest jakaś poszlaka. A jeszcze dziś z uporem maniaka lutowałem krótszy zestaw kabli przyłączeniowych - na darmo
Temat jeszcze zapodałem na elektrodzie i avrfreaks, na tym drugim polecili mi sprawdzić połączenia jednak nie tędy droga. Chyba jeszcze raz wezmę notę w łapkę i krok po kroku prześledzę, bo bankowo musi to być coś z tą funkcją uruchamiającą wyświetlacz...

Tak dokładnie wygląda efekt zamalowania całego ekranu.

Statystyki: Napisane przez mesho — 1 lut 2014, o 19:40

Re: SSD1289 inicjalizacja szum

2014-02-01T17:29:22+01:00

Witaj!

Podłączyłem wyświetlacz działa identycznie jak u kolegi, więc odpada wina wyświetlacza;) może już kolega poradził sobie z problemem?

Statystyki: Napisane przez Mscichu — 1 lut 2014, o 17:29

SSD1289 inicjalizacja szum

2014-01-30T15:29:40+01:00

Witam!

Wziąłem na tapetę sobie wyświetlacz HY-320 na sterowniku SSD1289. Na podstawie bibliotek ze strony http://sourceforge.net/projects/lcdtfthx8347a/files/code_release_src/ przygotowałem sobie funkcje najniższego rzędu, bez dodatków karty SD czy touchpanelu, aby dojść do jakiegokolwiek kontaktu z LCD.

Otóż gdy puszczam funkcje inicjalizującą, na ekranie wyskakuje szum jak na zdjęciu:

Kiedy puszczam funkcje testowe, zmienia się niecała pierwsza pozioma linia pikseli, reszta dalej bujnie szumi.

Popędzam wszystko z ATB, zgodnie z opisem LCD toleruje sygnały 3,3V więc wszystko zasilam 3,3V. Mikrokontroler Atmega32A, próbowałem z częstotliwościami 8MHz oraz 16MHz.

[syntax=c]/* lcd definition */
#define LCD_STER_DIR DDRD
#define LCD_STER PORTD
#define LCD_CS (1<#define LCD_RD (1<#define LCD_WR (1<#define LCD_RS (1<#define LCD_RESET (1<

/* 16 bitowa magistrala danych lcd */
#define LCD_DATA_L PORTC
#define LCD_DATA_H PORTA
#define LCD_DATA_L_DIR DDRC // for direction
#define LCD_DATA_H_DIR DDRA // for direction[/syntax]

Podłączam piny:
DB0 do DB7 -> PC0 do PC7
DB8 do DB15 -> PA0 do PA7
Sterujące jak w nagłówku czyli:
CS PD7
RD PD6
WR PD5
RS PD4
RESET PD3

[syntax=c]/*
*SSD1289.c
*
* Author: Guillaume Sahuc

This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program. If not, see .

*/

#include "board.h"
#include "color16bits.h"
#include "fonts.h"
#include "SSD1289.h"
#include
#include /* pour printf , sprintf ... */
#include /* pour abs */
#include "main.h"

#include
#include
#include
#include
#include

extern uint8_t buffer_16[6];
//extern uint8_t buffer_32[11];

// échange de valeur entre 2 adresses
void swap(uint16_t *a, uint16_t *b) {
uint16_t temp = *a;
*a = *b;
*b = temp;
}
//--------------------(--HIGHBYTE---,------LOWBYTE-)
void Lcd_Write_Com_2x8(uint8_t addr_H, uint8_t addr_L) {
LCD_STER &= ~(LCD_CS | LCD_RS);
LCD_DATA_H = addr_H;
LCD_DATA_L = addr_L;
LCD_STER &= ~(LCD_WR);
LCD_STER |= (LCD_WR | LCD_RS | LCD_CS);
}

void Lcd_Write_DATA_2x8(uint8_t data_H, uint8_t data_L) {
LCD_STER &= ~(LCD_CS);
LCD_STER |= (LCD_RS);
LCD_DATA_H = data_H;
LCD_DATA_L = data_L;
LCD_STER &= ~(LCD_WR);
LCD_STER |= (LCD_WR | LCD_CS);
}

void Lcd_Write_DATA_16(uint16_t data) {
LCD_STER &= ~(LCD_CS);
LCD_STER |= (LCD_RS);
LCD_DATA_H = data >> 8;
LCD_DATA_L = data;
LCD_STER &= ~(LCD_WR);
LCD_STER |= (LCD_WR | LCD_CS);
}

// envoi d'une donnée LSB sur le bus de données ( 8 bits LCD )
void Lcd_Write_DATA_8(uint8_t data) {
LCD_STER &= ~(LCD_CS);
LCD_STER |= (LCD_RS);
LCD_DATA_L = data;
LCD_STER &= ~(LCD_WR);
LCD_STER |= (LCD_WR | LCD_CS);
}

void Lcd_W_com_data_4x8(uint8_t address_H, uint8_t address_L, uint8_t data_H,
uint8_t data_L) {
Lcd_Write_Com_2x8(address_H, address_L); // addresse registre
Lcd_Write_DATA_2x8(data_H, data_L); // Donnée ŕ stocker dans le registre
}

// write command + data
void Lcd_W_com_data_8(uint8_t address_H, uint8_t address_L, uint8_t data) {
Lcd_Write_Com_2x8(address_H, address_L); // addresse registre
Lcd_Write_DATA_8(data); // Donnée ŕ stocker dans le registre
}

// Lecture d'un registre uniquement le LSB (8bits D7 ŕ D0)
uint8_t Lcd_Read_data_8() {
uint8_t data;
LCD_DATA_L_DIR = 0x00; // wejscie
LCD_STER &= ~(LCD_CS);
LCD_STER |= (LCD_RS);
LCD_STER &= ~(LCD_RD);
LCD_STER |= (LCD_RD);
data = LCD_DATA_L; // lecture du registre
LCD_STER |= (LCD_CS);
LCD_DATA_L_DIR = 0xFF; //z powrotem jako wyjscie
return data;
}

// Read 8 bits LSB register
// return 8 bits data from index register
uint8_t Lcd_R_com_data_8(uint8_t address_H, uint8_t address_L) {
Lcd_Write_Com_2x8(address_H, address_L); // addresse registre
return Lcd_Read_data_8(); // read register
}

void Lcd_Write_Com_Data(unsigned int com,unsigned int dat)
{
Lcd_Write_Com_2x8(com>>8,com);
Lcd_Write_DATA_2x8(dat>>8,dat);
}

// fonction définition de la zone écran + position sur l'ecran ( mode vertical )
void Lcd_address_set(uint16_t x1, uint16_t y1, uint16_t x2, uint16_t y2) {
uint8_t array[8] = { 0 };
memcpy(&array[0], &x1, sizeof(uint16_t));
memcpy(&array[2], &y1, sizeof(uint16_t));
memcpy(&array[4], &x2, sizeof(uint16_t));
memcpy(&array[6], &y2, sizeof(uint16_t));
Lcd_W_com_data_4x8(0x00, 0x44, array[5], array[1]); // end + start horizontal
Lcd_W_com_data_4x8(0x00, 0x45, array[2] & 0x01, array[3]);//vertical start
Lcd_W_com_data_4x8(0x00, 0x46, array[6] & 0x01, array[7]); //vertical end
Lcd_W_com_data_4x8(0x00, 0x4e, array[0], array[1]);//set GDDRAM adress counter
Lcd_W_com_data_4x8(0x00, 0x4f, array[2] & 0x01, array[3]);//set GDDRAM adress counter
Lcd_Write_Com_2x8(0x00, 0x22);// transform data into 16 bits bus before write to GRAM
}

// fonction de changement de position sur l'ecran
void Lcd_Position_Set(uint16_t x1, uint16_t y1) {
uint8_t array[4] = { 0 };
memcpy(&array[0], &x1, sizeof(uint16_t));
memcpy(&array[2], &y1, sizeof(uint16_t));
Lcd_W_com_data_4x8(0x00, 0x4e, array[0], array[1]);//set GDDRAM adress counter
Lcd_W_com_data_4x8(0x00, 0x4f, array[2] & 0x01, array[3]);//set GDDRAM adress counter
Lcd_Write_Com_2x8(0x00, 0x22);// transform data into 16 bits bus before write to GRAM
}

// conversion d'une donnée integer en string
// string[6]
void IntToStr(uint16_t dd, uint8_t* str) {
sprintf(str, "%d", dd);
}

// conversion d'une donnée long en string
// string[11]
void LongToStr(uint32_t dd, uint8_t* str) {
sprintf(str, "%ld", dd);
}

//dcolor = data color
//bgcolor = background color
//fonction d'affichage d'un caractere avec l'utilisation d'un user font
void Lcd_PutChar(uint16_t x, uint16_t y, uint8_t value, uint8_t dcolor_H,
uint8_t dcolor_L, uint8_t bgcolor_H, uint8_t bgcolor_L) {
uint8_t i, j;
//const FONT *FontTemp = fonts[UserFont];
const uint8_t *temp = FontTemp->data;
Lcd_address_set(x, y, x + (FontTemp->width - 1),
y + (FontTemp->height - 1));
temp += value * FontTemp->height;
for (j = 0; j < FontTemp->height; j++) {
for (i = 0; i < FontTemp->width; i++) {
if ((*temp & (1 << (7 - i))) != 0) {
Lcd_Write_DATA_2x8(dcolor_H, dcolor_L);
} else {
Lcd_Write_DATA_2x8(bgcolor_H, bgcolor_L);
}
}
temp++;
}
}

// fonction d'affichage sur l'écran : position + donnée ŕ afficher + couleur de la donnée + couleur de fond
void Lcd_print(uint16_t Column, uint16_t Row, uint8_t* str, uint8_t dcolor_H,
uint8_t dcolor_L, uint8_t bgcolor_H, uint8_t bgcolor_L) {
uint8_t MaxLineChar;
//const FONT *FontTemp = fonts[UserFont];
/*-----------------*/
MaxLineChar = (uint8_t) (LCD_WIDTH / (FontTemp->width));
/*-----------------*/
while (*str != '\0') {
if ((Column >= MaxLineChar * FontTemp->width) || (*str == 0x0D)
|| (*str == 0x0A))//ŕ chaque depassement de l'écran ou caractčre dédié = retour ŕ la ligne
{
Row += FontTemp->height;
Column = 0;
}
while ((*str == 0x0D) || (*str == 0x0A)) {
str++;
} //si plusieur retour ŕ la ligne on les ignores.
if (*str == '\0') {
break;
}
Lcd_PutChar(Column, Row, *str, dcolor_H, dcolor_L, bgcolor_H,
bgcolor_L);
Column += FontTemp->width;
str++;
}
}

void Init_LCD(void) {
LCD_DATA_L_DIR = 0xFF;
LCD_DATA_H_DIR = 0xFF;
LCD_DATA_L = 0xFF;
LCD_DATA_H = 0xFF;

LCD_STER_DIR = 0xFF;
LCD_STER |= LCD_CS | LCD_RD | LCD_WR | LCD_RS | LCD_RESET;

LCD_STER |= LCD_RESET;
_delay_ms(1);
LCD_STER &= ~(LCD_RESET);
_delay_ms(15);
LCD_STER |= LCD_RESET;
_delay_ms(15);

/*SSD1289*/
Lcd_W_com_data_4x8(0x00, 0x07, 0x00, 0x21); //display control
Lcd_W_com_data_4x8(0x00, 0x00, 0x00, 0x01); //oscillator start
Lcd_W_com_data_4x8(0x00, 0x07, 0x00, 0x23);
Lcd_W_com_data_4x8(0x00, 0x03, 0xAE, 0xAC);
Lcd_W_com_data_4x8(0x00, 0x0C, 0x00, 0x07);
Lcd_W_com_data_4x8(0x00, 0x0D, 0x00, 0x0F);
Lcd_W_com_data_4x8(0x00, 0x0E, 0x29, 0x00);
Lcd_W_com_data_4x8(0x00, 0x1E, 0x00, 0xB3);
_delay_ms(15);
Lcd_W_com_data_4x8(0x00, 0x01, 0x2b, 0x3F);
Lcd_W_com_data_4x8(0x00, 0x02, 0x06, 0x00);
Lcd_W_com_data_4x8(0x00, 0x10, 0x00, 0x00);
Lcd_W_com_data_4x8(0x00, 0x11, 0x60, 0xB0); // ID=11 AM=0
_delay_ms(15);
Lcd_W_com_data_4x8(0x00, 0x05, 0x00, 0x00);
Lcd_W_com_data_4x8(0x00, 0x06, 0x00, 0x00);
Lcd_W_com_data_4x8(0x00, 0x16, 0xEF, 0x1C);
Lcd_W_com_data_4x8(0x00, 0x17, 0x00, 0x03);
Lcd_W_com_data_4x8(0x00, 0x07, 0x02, 0x33);
Lcd_W_com_data_4x8(0x00, 0x0B, 0x53, 0x12);
Lcd_W_com_data_4x8(0x00, 0x0F, 0x00, 0x00);
_delay_ms(15);
Lcd_W_com_data_4x8(0x00, 0x41, 0x00, 0X00); // scroll screen 1
Lcd_W_com_data_4x8(0x00, 0x42, 0x00, 0x00); // scroll screen 2
Lcd_W_com_data_4x8(0x00, 0x48, 0x00, 0x00); // first screen start
Lcd_W_com_data_4x8(0x00, 0x49, 0x01, 0x3F); // first screen end
Lcd_W_com_data_4x8(0x00, 0x44, 0xEF, 0x00);
Lcd_W_com_data_4x8(0x00, 0x45, 0x00, 0x00);
Lcd_W_com_data_4x8(0x00, 0x46, 0x01, 0x3F);
Lcd_W_com_data_4x8(0x00, 0x4A, 0x00, 0x00); // second screen start
Lcd_W_com_data_4x8(0x00, 0x4B, 0x00, 0x00); // second screen end
_delay_ms(15);
Lcd_W_com_data_4x8(0x00, 0x30, 0x07, 0x07);
Lcd_W_com_data_4x8(0x00, 0x31, 0x07, 0x04);
Lcd_W_com_data_4x8(0x00, 0x32, 0x02, 0x04);
Lcd_W_com_data_4x8(0x00, 0x33, 0x02, 0x01);
Lcd_W_com_data_4x8(0x00, 0x34, 0x02, 0x03);
Lcd_W_com_data_4x8(0x00, 0x35, 0x02, 0x04);
Lcd_W_com_data_4x8(0x00, 0x36, 0x02, 0x04);
Lcd_W_com_data_4x8(0x00, 0x37, 0x05, 0x02);
Lcd_W_com_data_4x8(0x00, 0x3A, 0x03, 0x02);
Lcd_W_com_data_4x8(0x00, 0x3B, 0x05, 0x00);
Lcd_W_com_data_4x8(0x00, 0x23, 0x00, 0x00);
Lcd_W_com_data_4x8(0x00, 0x24, 0x00, 0x00);
Lcd_W_com_data_4x8(0x00, 0x25, 0x80, 0x00); //ajout
_delay_ms(20);
Lcd_Write_Com_2x8(0x00, 0x22);

}

// activation du mode scroll = rotation axe y de l'écran ( verticale )
void Lcd_Scroll_On(void) {
Lcd_W_com_data_4x8(0x00, 0x07, 0x02, 0x33);
}

void Lcd_Scroll_Off(void) {
Lcd_W_com_data_4x8(0x00, 0x07, 0x00, 0x33);
}

void Lcd_On(void) {
// Display ON Setting
Lcd_W_com_data_4x8(0x00, 0x07, 0x00, 0x21); //display control
Lcd_W_com_data_4x8(0x00, 0x00, 0x00, 0x01); //oscillator start
Lcd_W_com_data_4x8(0x00, 0x07, 0x00, 0x23);
Lcd_W_com_data_4x8(0x00, 0x10, 0x00, 0x00);
_delay_ms(30);
Lcd_W_com_data_4x8(0x00, 0x07, 0x00, 0x33);
Lcd_W_com_data_4x8(0x00, 0x11, 0x60, 0xB0); // ID=11 AM=0
Lcd_W_com_data_4x8(0x00, 0x02, 0x06, 0x00);
Lcd_Write_Com_2x8(0x00, 0x22);
}

void Lcd_Off(void) {
Lcd_W_com_data_4x8(0x00, 0x07, 0x00, 0x00);
Lcd_W_com_data_4x8(0x00, 0x00, 0x00, 0x00);
Lcd_W_com_data_4x8(0x00, 0x10, 0x00, 0x01);
}

void SDD1289_STANDBY_ON(void) {
// Display Off
Lcd_W_com_data_4x8(0x00, 0x10, 0x00, 0x01);

}

void SSD1289_STANDBY_OFF(void) {
// Start Oscillation
Lcd_W_com_data_4x8(0x00, 0x10, 0x00, 0x00);
}

/*! \configuration de la zone de scrolling.
*
* @param VL1 1er écran
* @param VL2 2eme écran
*
*/
void Lcd_ScrollAreaSetup(uint16_t VL1, uint16_t VL2) {
uint8_t array[4] = { 0 };
memcpy(&array[0], &VL1, sizeof(uint16_t));
memcpy(&array[2], &VL2, sizeof(uint16_t));
Lcd_W_com_data_4x8(0x00, 0x41, array[0], array[1]);
Lcd_W_com_data_4x8(0x00, 0x42, array[2], array[3]);
}

// allumage d'un pixel + couleur
void LCD_setPixel(uint16_t x, uint16_t y, uint8_t color_H, uint8_t color_L) {
Lcd_address_set(x, y, x, y); //x_start,y_start,x_end,y_end
Lcd_Write_DATA_2x8(color_H, color_L);
}

//affichage d'une boite pleine
void Lcd_Fill_Box(uint16_t x, uint16_t y, uint16_t longueur, uint16_t largeur,
uint8_t color_H, uint8_t color_L) {
uint16_t i, j;
Lcd_address_set(x, y, longueur, largeur); //x_start,y_start,x_end,y_end
for (i = 0; i != largeur + 1; i++) {
Lcd_Write_DATA_2x8(color_H, color_L);
for (j = 0; j != longueur + 1; j++) {
LCD_STER &= ~(LCD_CS);
LCD_STER &= ~(LCD_WR);
LCD_STER |= (LCD_WR);
LCD_STER |= (LCD_CS);
}
Lcd_address_set(x, y + i, 239, 319); //x_start,y_start,x_end,y_end

}
}

// Affichage d'une ligne
void Lcd_Line(uint16_t x0, uint16_t y0, uint16_t x1, uint16_t y1,
uint8_t color_H, uint8_t color_L) {
uint16_t dy = y1 - y0;
uint16_t dx = x1 - x0;
float m = 0;
uint16_t b = 0;

if ((dy == 0) && (dx == 0)) {
LCD_setPixel(x0, y0, color_H, color_L);
return;
} else if (dy == 0) {
Lcd_Fill_Box(x0, y0, x1, 1, color_H, color_L); // horizontal
return;
} else if (dx == 0) {
Lcd_Fill_Box(x0, y0, 0, y1, color_H, color_L); // vertical
return;
} else // if (dx != 0)
{
m = ((float) (dy)) / (dx);
b = y0 - (int) (m * x0);
}

Lcd_address_set(0, 0, 239, 319); //x_start,y_start,x_end,y_end

if (abs(dx) >= abs(dy)) {
if (x0 > x1) {
swap(&x0, &x1);
swap(&y0, &y1);
}

while (x0 <= x1) {
LCD_setPixel(x0, y0, color_H, color_L);
x0++;
if (x0 <= x1) {
y0 = (int) (m * x0) + b;
}
}
} else {
if (y0 > y1) {
swap(&x0, &x1);
swap(&y0, &y1);
}
while (y0 <= y1) {
LCD_setPixel(x0, y0, color_H, color_L);
y0++;
if (y0 <= y1) {
if (dx != 0) {
x0 = (uint16_t) ((float) ((y0 - b) / m));
}
}
}
}
}

// remplissage de l'ecran avec une couleur
void Lcd_Fill(uint8_t color_H, uint8_t color_L) // in vertical mode
{
uint16_t i, j;
Lcd_address_set(0, 0, 239, 319); //x_start,y_start,x_end,y_end
Lcd_Write_DATA_2x8(color_H, color_L);
for (i = 0; i != 320; i++) {
for (j = 0; j != 240; j++) {
LCD_STER &= ~(LCD_CS);
LCD_STER &= ~(LCD_WR);
LCD_STER |= (LCD_WR);
LCD_STER |= (LCD_CS);
}
}
}

// remplissage écran en mode horizontale
void Lcd_Fill_H(uint8_t color_H, uint8_t color_L) {
uint16_t i, j;
Lcd_W_com_data_4x8(0x00, 0x11, 0x60, 0x38); // registre qui permet de modifier l'orientation de l'écran "paysage" ( landscape )
Lcd_address_set(0, 0, 239, 319); //x_start,y_start,x_end,y_end
Lcd_Write_DATA_2x8(color_H, color_L);
for (j = 0; j != 240; j++) {
for (i = 0; i != 320; i++) {
LCD_STER &= ~(LCD_CS);
LCD_STER &= ~(LCD_WR);
LCD_STER |= (LCD_WR);
LCD_STER |= (LCD_CS);
}

}
//retour vers l'orientation portrait
Lcd_W_com_data_4x8(0x00, 0x11, 0x60, 0xB0);
; // MY=0, MX=0, MV=0, ML=1, BGR=0=RGB if 1=BGR, TEON=0
}

// affichage d'une boite non pleine ( position de départ + longueur + largeur + couleur )
void Lcd_Box(uint16_t x, uint16_t y, uint16_t longueur, uint16_t largeur,
uint8_t color_H, uint8_t color_L) {
/*+----------------------------+
| |
| |
+----------------------------+*/
Lcd_Line(x, y, longueur, y, color_H, color_L);
Lcd_Line(x + longueur, y, x + longueur, largeur, color_H, color_L);
Lcd_Line(x, y + largeur, longueur, y + largeur, color_H, color_L);
Lcd_Line(x, y, x, largeur, color_H, color_L);
}

// affichage d'un cercle ( radius = rayon )
void LCD_Circle(uint16_t Xpos, uint16_t Ypos, uint16_t Radius, uint8_t color_H,
uint8_t color_L) { //algo d'Andres
uint16_t D;/* Decision Variable */
uint16_t CurX;/* Current X Value */
uint16_t CurY;/* Current Y Value */

D = Radius - 1;
CurX = 0;
CurY = Radius;
while (CurY >= CurX) {
LCD_setPixel(Xpos + CurX, Ypos + CurY, color_H, color_L);
LCD_setPixel(Xpos + CurX, Ypos - CurY, color_H, color_L);
LCD_setPixel(Xpos - CurX, Ypos + CurY, color_H, color_L);
LCD_setPixel(Xpos - CurX, Ypos - CurY, color_H, color_L);
LCD_setPixel(Xpos + CurY, Ypos + CurX, color_H, color_L);
LCD_setPixel(Xpos + CurY, Ypos - CurX, color_H, color_L);
LCD_setPixel(Xpos - CurY, Ypos + CurX, color_H, color_L);
LCD_setPixel(Xpos - CurY, Ypos - CurX, color_H, color_L);
if (D >= 2 * CurX) {
D = D - 2 * CurX - 1;
CurX++;
} else if (D <= (2 * (Radius - CurY))) {
D = D + 2 * CurY - 1;
CurY--;
} else {
D += 2 * (CurY - CurX - 1);
CurY--;
CurX++;
}

}
}

// affichage d'un cercle plein
void LCD_Fill_Circle(uint16_t Xpos, uint16_t Ypos, uint16_t Radius,
uint8_t color_H, uint8_t color_L) {
while (Radius >= 0) {
LCD_Circle(Xpos, Ypos, Radius, color_H, color_L);
Radius--;
}
}

void Lcd_test(void) {
uint16_t i = 0;
Lcd_Fill(COLOR_2x8BITS_RED);
Lcd_Fill_H(COLOR_2x8BITS_GREEN);
Lcd_Fill(COLOR_2x8BITS_BLUE);
Lcd_Fill_H(COLOR_2x8BITS_YELLOW);
Lcd_Fill(COLOR_2x8BITS_TURQUOISE);
Lcd_Fill_H(COLOR_2x8BITS_OLIVE);
Lcd_Fill(COLOR_2x8BITS_LIGHTGREEN);
Lcd_Fill_H(COLOR_2x8BITS_SILVER);
Lcd_Fill(COLOR_2x8BITS_TOMATO);
Lcd_Fill_H(COLOR_2x8BITS_BLACK);
Lcd_Fill(COLOR_2x8BITS_DARKVIOLET);
Lcd_Fill(COLOR_2x8BITS_BLACK);
//Lcd_print(82, 5, "HELLO WORLD", COLOR_2x8BITS_WHITE, COLOR_2x8BITS_BLACK);
Lcd_Line(120, 0, 120, 319, COLOR_2x8BITS_RED);
Lcd_Line(0, 160, 239, 160, COLOR_2x8BITS_RED);
Lcd_Line(0, 0, 239, 319, COLOR_2x8BITS_RED);
Lcd_Line(0, 319, 239, 0, COLOR_2x8BITS_RED);
Lcd_Box(60, 80, 120, 160, COLOR_2x8BITS_RED);
LCD_Circle(120, 160, 60, COLOR_2x8BITS_RED);
LCD_Circle(120, 160, 119, COLOR_2x8BITS_RED);
LCD_Fill_Circle(60, 40, 10, COLOR_2x8BITS_RED);
LCD_Fill_Circle(100, 40, 10, COLOR_2x8BITS_GREEN);
LCD_Fill_Circle(140, 40, 10, COLOR_2x8BITS_BLUE);
LCD_Fill_Circle(180, 40, 10, COLOR_2x8BITS_WHITE);

for (i = 0; i != 321; i++) {
Lcd_ScrollAreaSetup(i, 0x0000);
_delay_ms(25);
}
}

void Lcd_test2(void) {
uint16_t i, j;
uint8_t color_H, color_L;
while (color_H != 0xFF) {
for (j = 10; j < LCD_LENGTH; j = j + 40) {
for (i = 10; i < LCD_WIDTH; i = i + 40) {
Lcd_Fill_Box(i, j, 20, 20, color_H, color_L);
}
}
color_H += 1;
color_L += 5;
}
}

void Lcd_test3(void) {
uint8_t color_H = 0, color_L = 0;

while (color_H != 0xFF) {
Lcd_Fill(color_H, color_L);
color_H += 1;
color_L += 5;
}

}

void Lcd_test4(void) {
//RED += 1;
//GREEN += 2;
BLUE += 1;
Lcd_Fill(COLOR2, COLOR1);
IntToStr(_COLOR16BITS.Word, buffer_16);
Lcd_print(0, 0, buffer_16, COLOR_2x8BITS_WHITE, COLOR_2x8BITS_BLACK);
}

void Lcd_test5(void) {
RED += 1;
GREEN += 2;
BLUE += 1;
Lcd_print(40, 0, "----HELLO WORLD----", COLOR_2x8BITS_WHITE,
COLOR_2x8BITS_BLACK);
Lcd_print(40, 20, "LOADING...", COLOR2, COLOR1, COLOR_2x8BITS_BLACK);
_delay_ms(1);
}[/syntax]

W czym może być problem?

Statystyki: Napisane przez mesho — 30 sty 2014, o 15:29