Re: Problem z odczytem i zapisem do pamięci eeprom

2014-08-15T21:48:09+01:00

Witam
U mnie kompilacja przeszła bez problemu:

To chyba bez znaczenia ale plik "lcd.h" zacząłem od
[syntax=c]#ifndef LCD_H_
#define LCD_H_[/syntax]
a kończę:
[syntax=c]#endif /* LCD_H_ */[/syntax]

...czyli troszkę inaczej niż jest u Ciebie.

edit: coś mu jednak nie pasuje bo są kłopoty z zapisywaniem - sory, ale już idę spać.

Pozdr.

Statystyki: Napisane przez kicajek — 15 sie 2014, o 21:48

Re: Problem z odczytem i zapisem do pamięci eeprom

2014-08-15T20:31:41+01:00

A czy mógłby ktoś sprawdzić czy u niego się to kompiluje?? Bo cos mi się wydaje ze to może być jakiś problem albo z linkerem, albo z biblioteką, przynajmniej tyle udało mi się do tej pory dowiedzieć.

Statystyki: Napisane przez mirost — 15 sie 2014, o 20:31

Re: Problem z odczytem i zapisem do pamięci eeprom

2014-08-14T12:47:07+01:00

Witam
Przeedytuj zamieszczony tu program - "SYNTAX wybierz", a następnie po rozwinięciu daj "C"; trochę źle się to czyta.

Pozdr.

Statystyki: Napisane przez kicajek — 14 sie 2014, o 12:47

Re: Problem z odczytem i zapisem do pamięci eeprom

2014-08-14T17:08:19+01:00

Aha faktycznie makrodefinicja, to wiele wyjaśnia . nagłówek dodaję i w "lcd.c" bo są tam odwołania do tych pamięci, i w pliku "main.c" żeby zapisywać tam zmienne.

Dalej nie mogę dojść do ładu z tym i nie wiem co źle robię dlatego wrzucam kod który do tej pory napisałem

lcd.c

[syntax=c]#include "lcd.h"
#include
#include
#include
#include
#include

//Definicja adresow DDRAM
#if ((LCD_Y == 4) && (LCD_X == 20))
#define LCD_LINE1 0x00 // adres 1 znaku 1 wiersza
#define LCD_LINE2 0x28 // adres 1 znaku 2 wiersza
#define LCD_LINE3 0x14 // adres 1 znaku 3 wiersza
#define LCD_LINE4 0x54 // adres 1 znaku 4 wiersza
#else
#define LCD_LINE1 0x00 // adres 1 znaku 1 wiersza
#define LCD_LINE2 0x40 // adres 1 znaku 2 wiersza
#define LCD_LINE3 0x10 // adres 1 znaku 3 wiersza
#define LCD_LINE4 0x50 // adres 1 znaku 4 wiersza
#endif

// Makra dostepu do portow
// PORT
#define PORT(X) SPORT(X)
#define SPORT(X) (PORT##X)
// PIN
#define PIN(X) SPIN(X)
#define SPIN(X) (PIN##X)
// DDR
#define DDR(X) SDDR(X)
#define SDDR(X) (DDR##X)

// Makrodefinicje na sygnalach sterujacych RS, RW, E
#define SET_RS (PORT(LCD_RSPORT) |= (1 << LCD_RS)) // stan wysoki na linii RS
#define CLR_RS (PORT(LCD_RSPORT) &= ~(1 << LCD_RS)) // stan niski na linii RS
#define SET_RW (PORT(LCD_RWPORT) |= (1 << LCD_RW)) // stan wysoki na linii RW
#define CLR_RW (PORT(LCD_RWPORT) &= ~(1 << LCD_RW)) // stan niski na linii RW
#define SET_E (PORT(LCD_EPORT) |= (1 << LCD_E)) // stan wysoki na linii E
#define CLR_E (PORT(LCD_EPORT) &= ~(1 << LCD_E)) // stan niski na linii E

// definicje cmd
#define LCDC_CLS 0b00000001 // czyszczenie wyœwietlacza
#define LCDC_HOME 0b00000010 // ustawienie kursora w poz 0.0

#define LCDC_ENTRY 0b00000100 // Okreslenie trybu pracy kursora/ okna wyswietlacza
#define LCDC_ENTRYR 0b00000010 // Przesuwanie kursora lub okna w prawo (inkrementacja adresu)
#define LCDC_ENTRYL 0b00000000 // Przesuwanie kursora lub okna w lewo (dekrementacja adresu)
#define LCDC_ENTRYW 0b00000001 // Przesuwa się okno, pozycja kursora na wyświetlaczu jest stała

#define LCDC_ONOFF 0b00001000 // wl/ wyl wyswietlacza
#define LCDC_DISPLAYON 0b00000100 // wlaczenie wyswietlacza
#define LCDC_DISPLAYOFF 0b00000000 // wylaczenie wyswietlacza
#define LCDC_CURSORON 0b00000010 // wlacz kursor
#define LCDC_CURSOROFF 0b00000000 // wylacz kursor
#define LCDC_CURSORBLINKON 0b00000001 // wlacz migotanie kursor
#define LCDC_CURSORBLINKOFF 0b00000000 // wylacz migotanie kursor

#define LCDC_SHIFT 0b00010000 // Przesuniecie
#define LCDC_SHIFTDATA 0b00001000 // Obrot danych na wyswietlaczu
#define LCDC_SHIFTCUR 0b00000000 // Przesuniecie kursora
#define LCDC_SHIFTR 0b00000100 // W lewo
#define LCDC_SHIFTL 0b00000000 // W prawo

#define LCDC_FUNC 0b00100000 // Funkcje inicjalizacji
#define LCDC_FUNC8B 0b00010000 // Tryb 8-bitowy
#define LCDC_FUNC4B 0b00000000 // Tryb 4-bitowy
#define LCDC_FUNC2L 0b00001000 // Dwa, lub cztery wiersze
#define LCDC_FUNC1L 0b00000000 // Jeden wiersz
#define LCDC_FUNC5x10 0b00000100 // Wielkosci znaku 5x10
#define LCDC_FUNC5x7 0b00000000 // Wielkosci znaku 5x10n

// DEKLARACJE FUNKCJI
uint8_t check_BF(void);
//

// Ustawienie pinow portu jako wyjscia
static inline void data_dir_out(void)
{
DDR(LCD_D7PORT) |= (1 << LCD_D7);
DDR(LCD_D6PORT) |= (1 << LCD_D6);
DDR(LCD_D5PORT) |= (1 << LCD_D5);
DDR(LCD_D4PORT) |= (1 << LCD_D4);
}
// Ustawienie pinow portu jako wejscia
static inline void data_dir_in(void)
{
DDR(LCD_D7PORT) &= ~(1 << LCD_D7);
DDR(LCD_D6PORT) &= ~(1 << LCD_D6);
DDR(LCD_D5PORT) &= ~(1 << LCD_D5);
DDR(LCD_D4PORT) &= ~(1 << LCD_D4);
}

// Wysylanie polowy bajtu
static inline void lcd_sendHalf(uint8_t data)
{
if(data&(1<<0)) PORT(LCD_D4PORT) |= (1 << LCD_D4);
else PORT(LCD_D4PORT) &= ~(1 << LCD_D4);

if(data&(1<<1)) PORT(LCD_D5PORT) |= (1 << LCD_D5);
else PORT(LCD_D5PORT) &= ~(1 << LCD_D5);

if(data&(1<<2)) PORT(LCD_D6PORT) |= (1 << LCD_D6);
else PORT(LCD_D6PORT) &= ~(1 << LCD_D6);

if(data&(1<<3)) PORT(LCD_D7PORT) |= (1 << LCD_D7);
else PORT(LCD_D7PORT) &= ~(1 << LCD_D7);
}

// Wysylanie calego bajtu
void _lcd_write_byte(unsigned char _data)
{
// Ustawienie pinow portu danych jako wyjscia
data_dir_out();

#if USE_RW == 1
CLR_RW;
#endif // USE_RW
SET_E;
lcd_sendHalf(_data>>4); // wysylanie starszej czesci bajtu
CLR_E;

SET_E;
lcd_sendHalf(_data); // wysylanie mlodszej czesci bajtu
CLR_E;

#if USE_RW == 1
while( check_BF() & (1 << 7) );
#else
_delay_us(120);
#endif // USE_RW
}

void lcd_write_cmd(uint8_t cmd)
{
CLR_RS;
_lcd_write_byte(cmd);
}

void lcd_write_data(uint8_t data)
{
SET_RS;
_lcd_write_byte(data);
}

#if USE_RW == 1
static inline uint8_t lcd_read_Half(void)
{
uint8_t result = 0;
if(PIN(LCD_D4PORT) & (1 << LCD_D4)) result |= (1<<0);
if(PIN(LCD_D5PORT) & (1 << LCD_D5)) result |= (1<<1);
if(PIN(LCD_D6PORT) & (1 << LCD_D6)) result |= (1<<2);
if(PIN(LCD_D7PORT) & (1 << LCD_D7)) result |= (1<<3);
return result;
}
#endif // USE_RW

#if USE_RW == 1
uint8_t _lcd_read_byte(void)
{
uint8_t result = 0;
data_dir_in();

SET_RW;
SET_E;
result |= (lcd_read_Half() << 4); //odczyt starszej czesci bajtu
CLR_E;
SET_E;
result |= (lcd_read_Half()); //odczyt mlodszej czesci bajtu
CLR_E;

return result;
}
#endif // USE_RW

#if USE_RW == 1
uint8_t check_BF(void)
{
CLR_RS;
return _lcd_read_byte();
}
#endif // USE_RW

// Inicjalizowanie pinow portow
void lcd_init(void)
{
data_dir_out();
DDR(LCD_RSPORT) |= (1 << LCD_RS);
DDR(LCD_EPORT) |= (1 << LCD_E);
#if USE_RW == 1
DDR(LCD_RWPORT) |= (1 << LCD_RW);
#endif // USE_RW

PORT(LCD_RSPORT) |= (1 << LCD_RS);
PORT(LCD_EPORT) |= (1 << LCD_E);
#if USE_RW == 1
PORT(LCD_RWPORT) |= (1 << LCD_RW);
#endif // USE_RW

_delay_ms(15);

PORT(LCD_EPORT) &= ~(1 << LCD_E);
PORT(LCD_RSPORT) &= ~(1 << LCD_RS);
#if USE_RW == 1
PORT(LCD_RWPORT) &= ~(1 << LCD_RW);
#endif // USE_RW
SET_E;
lcd_sendHalf(0x03); // tryb 8-bitowy DL = 1
CLR_E;

_delay_ms(4.1);

SET_E;
lcd_sendHalf(0x03); // tryb 8-bitowy DL = 1
CLR_E;

_delay_us(100);

SET_E;
lcd_sendHalf(0x03); // tryb 8-bitowy DL = 1
CLR_E;

_delay_us(100);

SET_E;
lcd_sendHalf(0x02); // tryb 4-bitowy DL = 0
CLR_E;

_delay_us(100);

// Tryb 4-bitowy, 2 wiersze, znak 5x7
lcd_write_cmd(LCDC_FUNC|LCDC_FUNC4B|LCDC_FUNC2L|LCDC_FUNC5x7);
// Wylaczenie kursora wyswietlacza i migania
lcd_write_cmd( LCDC_ONOFF );
// Wlaczenie wyswietlacza
lcd_write_cmd( LCDC_ONOFF|LCDC_DISPLAYON);
//Przesuwanie kursora w prawo bez przesuwania zawartosci ekranu
lcd_write_cmd( LCDC_ENTRY|LCDC_ENTRYR);
lcd_cls();
}

void lcd_cls(void)
{
lcd_write_cmd( LCDC_CLS);
#if USE_RW == 0
_delay_ms(4.9);
#endif // USE_RW
}

#if USE_LCD_CURSOR_HOME == 1
void lcd_home(void)
{
lcd_write_cmd( LCDC_CLS | LCDC_HOME );
#if USE_RW == 0
_delay_ms(4.9);
#endif // USE_RW
}
#endif // USE_LCD_CURSOR_HOME

#if USE_LCD_CURSOR_ON == 1
void lcd_cursor_on(void)
{
lcd_write_cmd(LCDC_ONOFF | LCDC_DISPLAYON | LCDC_CURSORON);
}

void lcd_cursor_off(void)
{
lcd_write_cmd(LCDC_ONOFF | LCDC_DISPLAYON | LCDC_CURSOROFF);
}
#endif // USE_LCD_CURSOR_ON

#if USE_LCD_CURSOR_BLINK == 1
void lcd_blink_on(void)
{
lcd_write_cmd(LCDC_ONOFF | LCDC_DISPLAYON | LCDC_CURSORON | LCDC_CURSORBLINKON);
}

void lcd_blink_off(void)
{
lcd_write_cmd(LCDC_ONOFF | LCDC_DISPLAYON | LCDC_CURSORON | LCDC_CURSORBLINKOFF);
}
#endif // USE_LCD_CURSOR_BLINK

void lcd_str(char *str)
{
register char znak;
while ( (znak = *(str++)) )
lcd_write_data( (znak>= 0x80 && znak<= 0x87) ? (znak & 0x07) : znak );
}

#if USE_LCD_STR_P == 1
void lcd_str_P(char *str)
{
register char znak;
while ( (znak = pgm_read_byte(str++)) )
lcd_write_data( (znak>= 0x80 && znak<= 0x87) ? (znak & 0x07) : znak );
}
#endif // USE_LCD_STR_P

#if USE_LCD_STR_E == 1
void lcd_str_E(char *str)
{
register char znak;
while (1)
{
znak = eeprom_read_byte( (uint8_t *)(str++) );
if( !znak || znak == 0xFF) break;
else
lcd_write_data( (znak>= 0x80 && znak<= 0x87) ? (znak & 0x07) : znak );

}
}
#endif // USE_LCD_STR_E

#if USE_LCD_INT == 1
void lcd_int(int val)
{
char bufor[17];
lcd_str( itoa(val, bufor, 10) );
}
#endif // USE_LCD_INT

#if USE_LCD_HEX == 1
void lcd_hex(int val)
{
char bufor[17];
lcd_str( itoa(val, bufor, 16) );
}
#endif // USE_LCD_HEX

#if USE_LCD_DEFCHAR == 1
void lcd_defchar(uint8_t nr, uint8_t *def_znak)
{
register uint8_t i, c;
lcd_write_cmd( 64 +((nr&0x07)*8));
for(i = 0; i < 8; i++)
{
c = *(def_znak++);
lcd_write_data(c);
}
}
#endif // USE_LCD_DEFCHAR

#if USE_LCD_DEFCHAR_P == 1
void lcd_defchar_P(uint8_t nr, uint8_t *def_znak)
{
register uint8_t i, c;
lcd_write_cmd( 64 +((nr&0x07)*8));
for(i = 0; i < 8; i++)
{
c = pgm_read_byte(def_znak++);
lcd_write_data(c);
}
}
#endif // USE_LCD_DEFCHAR_P

#if USE_LCD_DEFCHAR_E == 1
void lcd_defchar_E(uint8_t nr, uint8_t *def_znak)
{
register uint8_t i, c;
lcd_write_cmd( 64 +((nr&0x07)*8));
for(i = 0; i < 8; i++)
{
c = eeprom_read_byte(def_znak++);
lcd_write_data(c);
}
}
#endif // USE_LCD_DEFCHAR_E[/syntax]

a to lcd.h, zalaczylem w niej biblioteke bo jest tam odniesienie do uint8_t

[syntax=c]#ifndef LCD_H_INCLUDED
#define LCD_H_INCLUDED

#include

// Rozdzielczosc wyswietlacza LCD
#define LCD_Y 2 // liczba wierszy wyswietlacza
#define LCD_X 16 // liczba kolumn wyswietlacza

// Konfiguracja portow i pinow danych
#define LCD_D7PORT D
#define LCD_D7 3
#define LCD_D6PORT D
#define LCD_D6 2
#define LCD_D5PORT D
#define LCD_D5 1
#define LCD_D4PORT D
#define LCD_D4 0

// Konfiguracja portow i pinow sygna³ow RS, RW oraz E
#define LCD_RSPORT C
#define LCD_RS 0
#define LCD_RWPORT C
#define LCD_RW 1
#define LCD_EPORT C
#define LCD_E 2

// Obsluga pinu RW 0 1 - jesli obsluguje, 0 - jesli podlaczony do masy
#define USE_RW 1

// Urzywane funkcje 0 1 - jesli wlaczone, 0 - jesli wylaczone
#define USE_LCD_LOCATE 1

#define USE_LCD_STR_P 1 // Wysyla string umieszczony w pamieci FLASH
#define USE_LCD_STR_E 1 // Wysyla string umieszczony w pamieci EEPROM

#define USE_LCD_INT 1 // wyswietla liczbe dziesietna na LCD
#define USE_LCD_HEX 1 // wyswietla liczbe szesnastkowa na LCD

#define USE_LCD_DEFCHAR 1 // Wysyla zdefiniowany znak z pamieci RAM
#define USE_LCD_DEFCHAR_P 1 // Wysyla zdefiniowany znak z pamieci FLASH
#define USE_LCD_DEFCHAR_E 1 // Wysyla zdefiniowany znak z pamieci EEPROM

#define USE_LCD_CURSOR_HOME 1 // Ustaw kursor na pozycji poczatkowej
#define USE_LCD_CURSOR_ON 1 // Obsluga wl/wyl kursora
#define USE_LCD_CURSOR_BLINK 1 // Obsluga wl/wyl migotania kursora

// Definicje funkcji
void lcd_init(void);
void lcd_cls(void);
void lcd_str(char *str);

#if USE_LCD_CURSOR_HOME == 1
void lcd_home(void);
#endif // USE_LCD_CURSOR_HOME

#if USE_LCD_CURSOR_ON == 1
void lcd_cursor_on(void);
void lcd_cursor_off(void);
#endif // USE_LCD_CURSOR_ON

#if USE_LCD_CURSOR_BLINK == 1
void lcd_blink_on(void);
void lcd_blink_off(void);
#endif // USE_LCD_CURSOR_BLINK

#if USE_LCD_STR_P == 1
void lcd_str_P(char *str);
#endif // USE_LCD_STR_P

#if USE_LCD_STR_E == 1
void lcd_str_E(char *str);
#endif // USE_LCD_STR_E

#if USE_LCD_INT == 1
void lcd_int(int val);
#endif // USE_LCD_INT

#if USE_LCD_HEX == 1
void lcd_hex(int val);
#endif // USE_LCD_HEX

#if USE_LCD_DEFCHAR == 1
void lcd_defchar(uint8_t nr, uint8_t *def_znak);
#endif // USE_LCD_DEFCHAR

#if USE_LCD_DEFCHAR_P == 1
void lcd_defchar_P(uint8_t nr, uint8_t *def_znak);
#endif // USE_LCD_DEFCHAR_P

#if USE_LCD_DEFCHAR_E == 1
void lcd_defchar_E(uint8_t nr, uint8_t *def_znak);
#endif // USE_LCD_DEFCHAR_E

#endif // LCD_H_INCLUDED[/syntax]

Statystyki: Napisane przez mirost — 14 sie 2014, o 00:58

Re: Problem z odczytem i zapisem do pamięci eeprom

2014-08-14T00:54:07+01:00

"eeprom_read_byte" to nie funkcja tylko makrodefinicja stąd brak podpowiedzi kompilatora.
Gdzie dodajesz plik nagłówkowy "avr/eeprom.h"? Powinien być w pliku "lcd.c" ponieważ to w nim następuje odwołanie.

Statystyki: Napisane przez atmel — 14 sie 2014, o 00:54

Problem z odczytem i zapisem do pamięci eeprom

2014-08-14T00:14:24+01:00

Z racji tego że jest to mój pierwszy post na tym forum chciałbym się ze wszystkimi serdecznie przywitać, więc witam

Otóż mam problem jak w temacie. A sprawa wygląda tak. Pisałem sobie biblioteczkę do obsługi wyświetlacza LCD posługując się w tym celu książeczką pana Kardasia "Mikrokontrolery AVR Język C - podstawy programowania"
Wszystko sobie idzie jak po maśle. Inicjalizacja przeszła, LCD się odezwał i wydał swoje pierwsze tchnienie w postaci napisu "HELLO WORLD". Zapisanego do pamięci ram. Wszystko było w porządku napisałem dalej zgodnie z książeczką wyświetlanie napisów z pamięci flash. Wszystko działa. A tu nagle zgrzyt . Robię to samo w celu wyświetlania napisów zapisanych w pamięci eeprom, przepisałem wszystko zgodnie z książką

[syntax]znak = eeprom_read_byte( (uint8_t *)(str++) );[/syntax]

i niestety wyrzuca mi błąd o następującej treści;

||=== Build: Release in lcd (compiler: GNU GCC Compiler for AVR) ===|
obj\Release\lcd.o||In function `lcd_string_E':|
lcd.c|| undefined reference to `__eerd_byte_m8'|
||=== Build failed: 1 error(s), 0 warning(s) (0 minute(s), 0 second(s)) ===|

W oko żuciło mi sie równierz to ze mimo dołączonej biblioteki , nie uzyskałem podpowiedzi co do uzywanej funkcji. Zawsze jak coś pisałem, pisałem pierwsze litery i samo wyrzucało podpowiedz o jaką funkcje chodzi, a ta jest jakby niewidoczna.
Projekt jest pisany pod mikro-kontroler atmega8, dodam ze przeszukałem troszeczkę i niestety nie znalazłem odpowiedzi rozwiązującej mój problem, projekt pisze w Codeblocks. Bardzo bym prosił o pomoc bo mecze się z tym już od pewnego czasu.

Statystyki: Napisane przez mirost — 14 sie 2014, o 00:14

ATNEL tech-forum

Re: Problem z odczytem i zapisem do pamięci eeprom

Re: Problem z odczytem i zapisem do pamięci eeprom

Re: Problem z odczytem i zapisem do pamięci eeprom

Re: Problem z odczytem i zapisem do pamięci eeprom

Re: Problem z odczytem i zapisem do pamięci eeprom

Problem z odczytem i zapisem do pamięci eeprom