Mam napisany sterownik LCD. W swoim programie tworzę 2 tablice 16 znakowe. jedna z nich przechowuje napis, który ma się wyświetlić w pierwszym wierszu wyświetlacza, natomiast druga przechowuje napis dla drugiego wiersza wyświetlacza (posiadam LCD 2x16). Adresy do tych dwóch tablic przekazuję do funkcji disp_tab2, która obie te tablice wkłada w jedną większą tablicę (72 znakową), która to tablica jest później bajt po bajcie wysyłana na wyświetlacz.
Wszystko jest w porządku gdy funkcję disp_tab2 wywołam raz i jest to koniec jej działania. Gorzej jest, gdy np. funkcję tą wywołuję w nieskończonej pętli - wtedy na wyświetlaczu 'latają' dziwne najprzeróżniejsze znaki. Próbowałem już wstawiać _delay_ms(1000); po każdym wywołaniu disp_tab2, ale wtedy dziwne znaczki zmieniają się po prostu co sekundę - nadal wyświetla sę nie to co potrzebuję. Co jest nie tak z moją funkcją?
[syntax=c]void lcd_disp2 (char * tekst1, char *tekst2) //wyświetla tablice tekst1 (w pierwszym wierszu) i tekst2 (w drugim wierszu)
{
int tekst[72]; //nowa zmiena przechowująca połączone wiersze
int * w; //wskaźnik do tej nowej zmiennej
w = tekst;
int i = 0;
for (i = 0 ; i < 16 ; i++) //kopiowanie zawartości tekst2 do tekst
*(tekst + i) = *(tekst2 + i);
i = 0;
while(i < 16) //przenosi znaki do 40 miejsca (czyli do drugiej linii)
{
*(tekst + 40 + i) = *(tekst + i);
*(tekst + i) = '\0';
i++;
}
i = 0;
while (i < 16) //przenosi znaki z tekst do tekst2 (czyli na początek, bo 1 linia)
{
*(tekst + i) = *(tekst1 + i);
i++;
}
i = 0;
while (i < 16) //USUWANIE 'CHIŃSKICH ZNACZKÓW'
{
if (*(tekst + i) == '\0') //pierwszy wiersz
*(tekst + i) = ' ';
if (*(tekst + 40 + i) == '\0') //drugi wiersz
*(tekst + 40 + i) = ' ';
i++;
}
for (i = 0 ; i < 72 ; i++) //po kolei przesyła bajty tablicy tekst
lcd_write_data( *w++ );
}[/syntax]
Wstawię też cały swój sterownik LCD, gdyby był potrzebny do analizy kodu:
[syntax=c]//Przyjmę, że wyświetlacz jest podłączony do portu D (PD6 - PD0 : RS, RW, E, D7, D6, D5, D4)
//druga linia jest o 24 bajty w prawo od końca pierwszej linii, czyli 1 znak 2 wiersza zaczyna się po 40 bajtach
//zaczynamy od inicjalizacji LCD, czyli lcd_init(). Później tworzymy 2 tabele, w których wstawiamy tekst w 1 i w 2 linii.
//Następnie poleceniem lcd_disp2 (z argumentami w postaci nazw tabel) wyświetlamy napis.
#include <avr/io.h>
#include <util/delay.h>
#include "lcd.h"
#include "klaw_7seg.h"
//MAKRODEFINICJE:
#define SET_RS PORTD |= (1 << 6)
#define CLR_RS PORTD &= ~(1 << 6)
#define SET_RW PORTD |= (1 << 5)
#define CLR_RW PORTD &= ~(1 << 5)
#define SET_E PORTD |= (1 << 4)
#define CLR_E PORTD &= ~(1 << 4)
//END MAKRODEFINICJE
//KOMENDY LCD (przesyłane poprzez lcd_write_cmd)
#define LCDC_CLS 0x01 //czyści wyświetlacz
#define LCDC_HOME 0x02 //kursor w pozycji początkowej
#define LCDC_ENTRY 0x04 //ustawia bit D2 w celu zmiany trybu Entry Mode Set (z tabeli LCD)
#define LCDC_ENTRYR 0x02 //przesuwanie kursora (lub okna) w prawo (wymaga LCDC_ENTRY)
#define LCDC_ENTRYL 0 //przesuwanie w lewo
#define LCDC_MODEMOVE 0x01 //kursor w miejscu, przesuwa się zawartośc okna (wymaga LCDC_ENTRY) -- to samo co LCDC_SHIFTDISP ?
#define LCDC_ON 0x08 //ustawia bit D3 w celu zmiany trybu Dispaly On/Off (z tabeli LCD)
#define LCDC_DISPLAYON 0x04 //włącza wyświetlacz (wymaga LCDC_ON)
#define LCDC_CURSORON 0x02 //włącza kursor (wymaga LCDC_ON)
#define LCDC_BLINKON 0x01 //włącza miganie kursora (wymaga LCDC_ON)
#define LCDC_SHIFT 0x10 //ustawia bit D4 w celu zmiany trybu Cursor/Display Shift (tabela LCD)
#define LCDC_SHIFTDISP 0x08 //kursor w miejscu, przesuwa się zawartośc okna (wymaga LCDC_SHIFT) -- to samo co LCDC_MODEMOVE ?
#define LCDC_SHIFTR 0x04 //przesuwanie kursora w prawo (wymaga LCDC_SHIFT)
#define LCDC_SHIFTL 0 //przesuwanie kursora w lewo (wymaga LCDC_SHIFT)
#define LCDC_FUNC 0x20 //ustawia bit D5 w celu zmiany trybu Function Set (tabela LCD)
#define LCDC_FUNC8b 0x10 //ustawia 8-bit w Function Set (wymaga LCDC_FUNC)
#define LCDC_FUNC4b 0 //ustawia 4-bit w Function Set (wymaga LCDC_FUNC)
#define LCDC_FUNC2L 0x08 //ustawia tryb 2-wierszowy (wymaga LCDC_FUNC)
#define LCDC_FUNC1L 0 //ustawia tryb 1-wierszowy (wymaga LCDC_FUNC)
#define LCDC_FUNC5x10 0x4 //ustawia znaki 5x10 (wymaga LCDC_FUNC)
#define LCDC_FUNC5x7 0 //ustawia znaki 5x7 (wymaga LCDC_FUNC)
#define LCDC_CGA 0x40
#define LCDC_DDA 0x80
//KONIEC KOMEND
//DEKLARACJE FUNKCJI
static inline void data_dir_out (void);
static inline void data_dir_in (void);
static inline void lcd_send_half (uint8_t _data);
void lcd_send_byte(char data);
static inline uint8_t lcd_read_half (void);
uint8_t lcd_read_byte (void);
uint8_t BF_busy (void);
void lcd_write_data (uint8_t data);
void lcd_write_cmd (uint8_t data);
void lcd_init (void);
void lcd_clr (void);
void lcd_disp (char * tekst);
void lcd_disp2 (char * tekst, char *tekst2);
void lcd_cursor_on (void);
void lcd_cursor_off (void);
void lcd_cursor_home (void);
void lcd_cursor_blink_on (void);
void lcd_cursor_blink_off (void);
//****************MAIN**************************
//int main()
//{
//lcd_init(); //INICJALIZACJA LCD
////lcd_clr();
//char tab[72] = "test"; //TEKST W 1 LINII
//char tab2[72] = "test2"; //TEKST W 2 LINII
//lcd_disp2 (tab, tab2); //WYŚWIETL PRZYKŁADOWY TEKST
//
//return 0;
//}
//****************END OF MAIN***********************
//**********FUNKCJE***************
void lcd_init (void) //INICJALIZACJA LCD
{
DDRD |= 0b01111111; //po co suma logiczna?
SET_RS;
SET_E;
SET_RW;
_delay_ms(15);
CLR_E;
CLR_RS;
CLR_RW;
SET_E;
lcd_send_half(0x03); //tryb 8-bit
CLR_E;
_delay_ms(4.1);
SET_E;
lcd_send_half(0x03); //tryb 8-bit
CLR_E;
_delay_us(100);
SET_E;
lcd_send_half(0x03); //tryb 8-bit
CLR_E;
_delay_us(100);
SET_E;
lcd_send_half(0x02); //tryb 4-bit
CLR_E;
_delay_us(100);
//USTAWIENIA LCD
//tryb 4-bit, 2 wiersze, znak 5x7:
lcd_write_cmd( LCDC_FUNC | LCDC_FUNC4b | LCDC_FUNC2L | LCDC_FUNC5x7 );
//wyłączenie wyświetlacza
lcd_write_cmd( LCDC_ON ); //po prostu nie aktywujemy LCDC_DISPLAYON
//włączenie wyświetlacza:
lcd_write_cmd( LCDC_ON | LCDC_DISPLAYON );
//przesuwanie kurosra w prawo bez przesuwania zawartości ekranu:
lcd_write_cmd( LCDC_ENTRY | LCDC_ENTRYR );
//czyszczenie ekranu:
lcd_clr();
}
//***********USTAWIENIE IN/OUT
void data_dir_out (void) //ustawia piny D4-D7 jako wyjścia (aby przesłac dane do LCD)
{
DDRD |= 0x0F;
}
void data_dir_in (void) //ustawia piny D4-D7 jako wejścia (aby odczytac dane z LCD)
{
DDRD &= ~(0x0F);
}
//************ZAPIS**************
//*******************************
static inline void lcd_send_half (uint8_t _data) //PRZESYŁA 4BIT-Y do wyświetlacza
{
PORTD = (PORTD & 0xF0) | (_data & 0x0F);
}
void lcd_send_byte(char data) //PRZESYŁA CAŁY BAJT do wyświetlacza
{
data_dir_out();
CLR_RW; //0 na RW (czyli zapis)
SET_E;
lcd_send_half(data >> 4); //najpierw starsza częśc bajtu
CLR_E;
SET_E;
lcd_send_half(data); //później młodsza częśc bajtu
CLR_E;
while ( BF_busy() );
}
void lcd_write_data (uint8_t data) //przeslanie danych
{
SET_RS;
lcd_send_byte(data);
}
void lcd_write_cmd (uint8_t data) //przeslanie komendy
{
CLR_RS;
lcd_send_byte(data);
}
//**********ODCZYT**************
//*******************************
static inline uint8_t lcd_read_half (void) //odczytuje 4 bity z 1 jednego bajt
{
//uint8_t _odczyt = (PIND & 0x0F);
//return _odczyt;
uint8_t _odczyt = 0;
if(PIND & 0x0F) _odczyt |= PIND;
return _odczyt;
}
uint8_t lcd_read_byte (void) //odczytuje cały bajt z wyświetlacza
{
uint8_t odczyt = 0;
data_dir_in();
SET_RW;
SET_E;
odczyt = (lcd_read_half() << 4); //odczyt starszej części bajtu
CLR_E;
SET_E;
odczyt |= lcd_read_half(); //odczyt młodszej części bajtu (sterownik LCD wyśle ją "na siłę", mimo że nie potrzebujemy tej części do odczytu BF)
CLR_E;
return odczyt;
}
//*************RESZTA FUNKCJI***************
//******************************************
uint8_t BF_busy (void) //zwraca stan BF
{
CLR_RS;
return ( lcd_read_byte() & (1 << 7) ); //sprawdzamy 7-my bit odcztanego bajtu (czyli BF)
}
void lcd_clr (void) //CZYSZCZENIE WYŚWIETLACZA
{
lcd_write_cmd( LCDC_CLS );
}
//****************WYŚWIETLANIE*********************
//*************************************************
void lcd_disp (char * tekst) //wyświetla tablice tekst
{
while ( *tekst )
lcd_write_data( *tekst++ );
}
void lcd_disp2 (char * tekst1, char *tekst2) //wyświetla tablice tekst (w pierwszym wierszu) i tekst2 (w drugim wierszu)
{
int tekst[72]; //nowa zmiena przechowująca połączone wiersze
int * w; //wskaźnik do tej nowej zmiennej
w = tekst;
int i = 0;
for (i = 0 ; i < 16 ; i++) //kopiowanie zawartości tekst2 do tekst
*(tekst + i) = *(tekst2 + i);
i = 0;
while(i < 16) //przenosi znaki do 40 miejsca (czyli do drugiej linii)
{
*(tekst + 40 + i) = *(tekst + i);
*(tekst + i) = '\0';
i++;
}
i = 0;
while (i < 16) //przenosi znaki z tekst do tekst2 (czyli na początek, bo 1 linia)
{
*(tekst + i) = *(tekst1 + i);
i++;
}
i = 0;
while (i < 16) //USUWANIE 'CHIŃSKICH ZNACZKÓW'
{
if (*(tekst + i) == '\0') //pierwszy wiersz
*(tekst + i) = ' ';
if (*(tekst + 40 + i) == '\0') //drugi wiersz
*(tekst + 40 + i) = ' ';
i++;
}
for (i = 0 ; i < 72 ; i++) //po kolei przesyła bajty tablicy tekst2
lcd_write_data( *w++ );
}
//*****************************************
//*****************************************
void lcd_cursor_on (void) //włącza kursor (i wyświetlacz)
{
lcd_write_cmd( LCDC_ON | LCDC_DISPLAYON | LCDC_CURSORON );
}
void lcd_cursor_off (void) //włącza kursor (i wyświetlacz)
{
lcd_write_cmd( LCDC_ON | LCDC_DISPLAYON); //po prostu nie aktywujemy bitu odpowiedzialnego za włączenie kursora
}
void lcd_cursor_home (void)
{
lcd_write_cmd( LCDC_HOME );
}
void lcd_cursor_blink_on (void)
{
lcd_write_cmd( LCDC_ON | LCDC_DISPLAYON | LCDC_CURSORON | LCDC_BLINKON );
}
void lcd_cursor_blink_off (void)
{
lcd_write_cmd( LCDC_ON | LCDC_DISPLAYON | LCDC_CURSORON );
}[/syntax]
A tutaj jest moja funkcja main():
[syntax=c]int main()
{
init_klaw();
lcd_init(); //INICJALIZACJA LCD
//lcd_clr();
char wiersz1[16] = " "; //TEKST W 1 LINII
char wiersz2[16] = " "; //TEKST W 2 LINII
wiersz1[2] = 0xFF;
//tab2[15] = 'f';
lcd_disp2 (wiersz1, wiersz2);
while (1)
{
lcd_disp2 (wiersz1, wiersz2); //WYŚWIETL PRZYKŁADOWY TEKST
//_delay_ms(1000);
}
return 0;
}[/syntax]Statystyki: Napisane przez Loreno — 6 paź 2015, o 18:33
]]>