Elektroda.pl
Elektroda.pl
X
Proszę, dodaj wyjątek www.elektroda.pl do Adblock.
Dzięki temu, że oglądasz reklamy, wspierasz portal i użytkowników.

Toporne początki z atmega8 [C]

revolt 06 Paź 2009 01:06 3150 18
  • #1 06 Paź 2009 01:06
    revolt
    Poziom 34  

    Witam. Po mrugający ledach i wyświetlaczach 7 segmentowych postanowiłem pobawić się LCD. Ze strony http://radzio.dxp.pl/hd44780/ ściągnąłem biblioteki w wersji 4 bit. Wyświetlacz to: http://www.artronic.pl/o_produkcie.php?id=576?
    Połączenia:
    DB4 - PB1
    DB5 - PDO
    DB6 - PB2
    DB7 - PD1
    RS - PD3
    E - PD2
    R/W - PD4.

    Bibliotekę zmodyfikowałem następująco:

    Code:
    #include <avr/io.h>
    
    #include <util/delay.h>

    //-------------------------------------------------------------------------------------------------
    //
    // Konfiguracja sygnałów sterujących wyświetlaczem.
    // Można zmienić stosownie do potrzeb.
    //
    //-------------------------------------------------------------------------------------------------
    #define LCD_RS_DIR      DDRD
    #define LCD_RS_PORT    PORTD
    #define LCD_RS_PIN      PIND
    #define LCD_RS         (1 << PD3)

    #define LCD_RW_DIR      DDRD
    #define LCD_RW_PORT      PORTD
    #define LCD_RW_PIN      PIND
    #define LCD_RW         (1 << PD4)

    #define LCD_E_DIR      DDRD
    #define LCD_E_PORT      PORTD
    #define LCD_E_PIN      PIND
    #define LCD_E         (1 << PD2)

    #define LCD_DB4_DIR      DDRB
    #define LCD_DB4_PORT   PORTB
    #define LCD_DB4_PIN      PINB
    #define LCD_DB4         (1 << PB1)

    #define LCD_DB5_DIR      DDRD
    #define LCD_DB5_PORT   PORTD
    #define LCD_DB5_PIN      PIND
    #define LCD_DB5         (1 << PD0)

    #define LCD_DB6_DIR      DDRB
    #define LCD_DB6_PORT   PORTB
    #define LCD_DB6_PIN      PINB
    #define LCD_DB6         (1 << PB2)

    #define LCD_DB7_DIR      DDRD
    #define LCD_DB7_PORT   PORTD
    #define LCD_DB7_PIN      PIND
    #define LCD_DB7         (1 << PD1)

    //-------------------------------------------------------------------------------------------------
    //
    // Instrukcje kontrolera Hitachi HD44780
    //
    //-------------------------------------------------------------------------------------------------





    #define HD44780_CLEAR               0x01

    #define HD44780_HOME               0x02

    #define HD44780_ENTRY_MODE            0x04
       #define HD44780_EM_SHIFT_CURSOR      0
       #define HD44780_EM_SHIFT_DISPLAY   1
       #define HD44780_EM_DECREMENT      0
       #define HD44780_EM_INCREMENT      2

    #define HD44780_DISPLAY_ONOFF         0x08
       #define HD44780_DISPLAY_OFF         0
       #define HD44780_DISPLAY_ON         4
       #define HD44780_CURSOR_OFF         0
       #define HD44780_CURSOR_ON         2
       #define HD44780_CURSOR_NOBLINK      0
       #define HD44780_CURSOR_BLINK      1

    #define HD44780_DISPLAY_CURSOR_SHIFT   0x10
       #define HD44780_SHIFT_CURSOR      0
       #define HD44780_SHIFT_DISPLAY      8
       #define HD44780_SHIFT_LEFT         0
       #define HD44780_SHIFT_RIGHT         4

    #define HD44780_FUNCTION_SET         0x20
       #define HD44780_FONT5x7            0
       #define HD44780_FONT5x10         4
       #define HD44780_ONE_LINE         0
       #define HD44780_TWO_LINE         8
       #define HD44780_4_BIT            0
       #define HD44780_8_BIT            16

    #define HD44780_CGRAM_SET            0x40

    #define HD44780_DDRAM_SET            0x80

    //-------------------------------------------------------------------------------------------------
    //
    // Deklaracje funkcji
    //
    //-------------------------------------------------------------------------------------------------

    void LCD_WriteCommand(unsigned char);
    unsigned char LCD_ReadStatus(void);
    void LCD_WriteData(unsigned char);
    unsigned char LCD_ReadData(void);
    void LCD_WriteText(char *);
    void LCD_GoTo(unsigned char, unsigned char);
    void LCD_Clear(void);
    void LCD_Home(void);
    void LCD_Initalize(void);


    Natomiast plik główny:
    Code:
    #include <avr/io.h>
    
    #include <util/delay.h>
    #include <moje/HD44780.h>


    void _LCD_OutNibble(unsigned char nibbleToWrite)
    {

    if(nibbleToWrite & 0x01)
       LCD_DB4_PORT |= LCD_DB4;
    else
       LCD_DB4_PORT  &= ~LCD_DB4;

    if(nibbleToWrite & 0x02)
       LCD_DB5_PORT |= LCD_DB5;
    else
       LCD_DB5_PORT  &= ~LCD_DB5;

    if(nibbleToWrite & 0x04)
       LCD_DB6_PORT |= LCD_DB6;
    else
       LCD_DB6_PORT  &= ~LCD_DB6;

    if(nibbleToWrite & 0x08)
       LCD_DB7_PORT |= LCD_DB7;
    else
       LCD_DB7_PORT  &= ~LCD_DB7;
    }
    //-------------------------------------------------------------------------------------------------
    //
    // Funkcja wystawiająca półbajt na magistralę danych
    //
    //-------------------------------------------------------------------------------------------------
    unsigned char _LCD_InNibble(void)
    {
    unsigned char tmp = 0;

    if(LCD_DB4_PIN & LCD_DB4)
       tmp |= (1 << 0);
    if(LCD_DB5_PIN & LCD_DB5)
       tmp |= (1 << 1);
    if(LCD_DB6_PIN & LCD_DB6)
       tmp |= (1 << 2);
    if(LCD_DB7_PIN & LCD_DB7)
       tmp |= (1 << 3);
    return tmp;
    }
    //-------------------------------------------------------------------------------------------------
    //
    // Funkcja zapisu bajtu do wyświetacza (bez rozróżnienia instrukcja/dane).
    //
    //-------------------------------------------------------------------------------------------------
    void _LCD_Write(unsigned char dataToWrite)
    {
    LCD_DB4_DIR |= LCD_DB4;
    LCD_DB5_DIR |= LCD_DB5;
    LCD_DB6_DIR |= LCD_DB6;
    LCD_DB7_DIR |= LCD_DB7;

    LCD_RW_PORT &= ~LCD_RW;
    LCD_E_PORT |= LCD_E;
    _LCD_OutNibble(dataToWrite >> 4);
    LCD_E_PORT &= ~LCD_E;
    LCD_E_PORT |= LCD_E;
    _LCD_OutNibble(dataToWrite);
    LCD_E_PORT &= ~LCD_E;
    while(LCD_ReadStatus()&0x80);
    }
    //-------------------------------------------------------------------------------------------------
    //
    // Funkcja odczytu bajtu z wyświetacza (bez rozróżnienia instrukcja/dane).
    //
    //-------------------------------------------------------------------------------------------------

    unsigned char _LCD_Read(void)
    {
    unsigned char tmp = 0;
    LCD_DB4_DIR &= ~LCD_DB4;
    LCD_DB5_DIR &= ~LCD_DB5;
    LCD_DB6_DIR &= ~LCD_DB6;
    LCD_DB7_DIR &= ~LCD_DB7;

    LCD_RW_PORT |= LCD_RW;
    LCD_E_PORT |= LCD_E;
    tmp |= (_LCD_InNibble() << 4);
    LCD_E_PORT &= ~LCD_E;
    LCD_E_PORT |= LCD_E;
    tmp |= _LCD_InNibble();
    LCD_E_PORT &= ~LCD_E;
    return tmp;
    }

    //-------------------------------------------------------------------------------------------------
    //
    // Funkcja zapisu rozkazu do wyświetlacza
    //
    //-------------------------------------------------------------------------------------------------
    void LCD_WriteCommand(unsigned char commandToWrite)
    {
    LCD_RS_PORT &= ~LCD_RS;
    _LCD_Write(commandToWrite);
    }

    //-------------------------------------------------------------------------------------------------
    //
    // Funkcja odczytu bajtu statusowego
    //
    //-------------------------------------------------------------------------------------------------
    unsigned char LCD_ReadStatus(void)
    {
    LCD_RS_PORT &= ~LCD_RS;
    return _LCD_Read();
    }
    //-------------------------------------------------------------------------------------------------
    //
    // Funkcja zapisu danych do pamięci wyświetlacza
    //
    //-------------------------------------------------------------------------------------------------
    void LCD_WriteData(unsigned char dataToWrite)
    {
    LCD_RS_PORT |= LCD_RS;
    _LCD_Write(dataToWrite);
    }
    //-------------------------------------------------------------------------------------------------
    //
    // Funkcja odczytu danych z pamięci wyświetlacza
    //
    //-------------------------------------------------------------------------------------------------
    unsigned char LCD_ReadData(void)
    {
    LCD_RS_PORT |= LCD_RS;
    return _LCD_Read();
    }
    //-------------------------------------------------------------------------------------------------
    //
    // Funkcja wyświetlenia napisu na wyswietlaczu.
    //
    //-------------------------------------------------------------------------------------------------
    void LCD_WriteText(char * text)
    {
    while(*text)
      LCD_WriteData(*text++);
    }
    //-------------------------------------------------------------------------------------------------
    //
    // Funkcja ustawienia współrzędnych ekranowych
    //
    //-------------------------------------------------------------------------------------------------
    void LCD_GoTo(unsigned char x, unsigned char y)
    {
    LCD_WriteCommand(HD44780_DDRAM_SET | (x + (0x40 * y)));
    }
    //-------------------------------------------------------------------------------------------------
    //
    // Funkcja czyszczenia ekranu wyświetlacza.
    //
    //-------------------------------------------------------------------------------------------------
    void LCD_Clear(void)
    {
    LCD_WriteCommand(HD44780_CLEAR);
    _delay_ms(2);
    }
    //-------------------------------------------------------------------------------------------------
    //
    // Funkcja przywrócenia początkowych współrzędnych wyświetlacza.
    //
    //-------------------------------------------------------------------------------------------------
    void LCD_Home(void)
    {
    LCD_WriteCommand(HD44780_HOME);
    _delay_ms(2);
    }
    //-------------------------------------------------------------------------------------------------
    //
    // Procedura inicjalizacji kontrolera HD44780.
    //
    //-------------------------------------------------------------------------------------------------
    void LCD_Initalize(void)
    {
    unsigned char i;
    LCD_DB4_DIR |= LCD_DB4; // Konfiguracja kierunku pracy wyprowadzeń
    LCD_DB5_DIR |= LCD_DB5; //
    LCD_DB6_DIR |= LCD_DB6; //
    LCD_DB7_DIR |= LCD_DB7; //
    LCD_E_DIR    |= LCD_E;   //
    LCD_RS_DIR    |= LCD_RS;  //
    LCD_RW_DIR    |= LCD_RW;  //
    _delay_ms(15); // oczekiwanie na ustalibizowanie się napiecia zasilajacego
    LCD_RS_PORT &= ~LCD_RS; // wyzerowanie linii RS
    LCD_E_PORT &= ~LCD_E;  // wyzerowanie linii E
    LCD_RW_PORT &= ~LCD_RW;
    for(i = 0; i < 3; i++) // trzykrotne powtórzenie bloku instrukcji
      {
      LCD_E_PORT |= LCD_E; //  E = 1
      _LCD_OutNibble(0x03); // tryb 8-bitowy
      LCD_E_PORT &= ~LCD_E; // E = 0
      _delay_ms(5); // czekaj 5ms
      }

    LCD_E_PORT |= LCD_E; // E = 1
    _LCD_OutNibble(0x02); // tryb 4-bitowy
    LCD_E_PORT &= ~LCD_E; // E = 0

    _delay_ms(1); // czekaj 1ms
    LCD_WriteCommand(HD44780_FUNCTION_SET | HD44780_FONT5x7 | HD44780_TWO_LINE | HD44780_4_BIT); // interfejs 4-bity, 2-linie, znak 5x7
    LCD_WriteCommand(HD44780_DISPLAY_ONOFF | HD44780_DISPLAY_OFF); // wyłączenie wyswietlacza
    LCD_WriteCommand(HD44780_CLEAR); // czyszczenie zawartosći pamieci DDRAM
    LCD_WriteCommand(HD44780_ENTRY_MODE | HD44780_EM_SHIFT_CURSOR | HD44780_EM_INCREMENT);// inkrementaja adresu i przesuwanie kursora
    LCD_WriteCommand(HD44780_DISPLAY_ONOFF | HD44780_DISPLAY_ON | HD44780_CURSOR_OFF | HD44780_CURSOR_NOBLINK); // włącz LCD, bez kursora i mrugania
    }


    int main(void)
    {
      LCD_Initalize();
       
      while(1)
      {   
      LCD_WriteText("lalalal");
             }
    }



    Wkleiłem na wszelki wypadek wszystko. Niestety na wyświetlaczu nic nie widać.
    Czy po zasileniu (nawet bez mikro) taki wyświetlacz powinien się "zaświecić"? Bo już nie wiem czy może LCD już zabity czy to programowo jest źle. Wszystko jest zasilone z USB (atmega i wyświetlacz - może nie wyrabia?).

    0 18
  • Pomocny post
    #3 06 Paź 2009 08:39
    wojtek_84
    Poziom 13  

    A z kontrastem wszystko ok ? O ile dobrze pamiętam to włączony wyświetlacz bez procesora wyświetlał czarne pola w górnej linii, ale nie jestem pewien.

    0
  • #4 06 Paź 2009 10:51
    revolt
    Poziom 34  

    No właśnie kompletne zero. Myślałem że się chociaż trochę zaciemni.

    Dodano po 18 [minuty]:

    Szkło pod metalową osłoną jest pęknięte :( Kupię nowy dzisiaj i napiszę co i jak.

    0
  • Pomocny post
    #5 06 Paź 2009 10:59
    _Robak_
    Poziom 33  

    To nawet nie masz co kombinowac z biblioteka dopoki nie bedziesz mial czarnych pol na gornej linii. Tak jak kolega wyzej pisal, przez zly kontrast mozesz nic nie widziec.

    0
  • Pomocny post
    #6 06 Paź 2009 14:09
    dawid512
    Poziom 32  

    Podłącz R/W do masy no chyba że na siłę chcesz z tego korzystać. Jeżeli pojawią się kwadraciki w pierwszej linii to znaczy że jest ok. Teraz dopiero możesz kombinować z softem. Po za tym tak jak koledzy wspominali pokombinuj z kontrastem czyli potencjometrem ustaw odpowiednie napięcie na 3 nóżce LCD.

    0
  • #7 06 Paź 2009 19:38
    revolt
    Poziom 34  

    Nowy LCD śmiga w wersji z R/W i bez. Dzięki za pomoc.

    Dodano po 3 [godziny] 12 [minuty]:

    W sumie to już mam pytanie :)
    Czy można zdeklarować tablicę liter?
    Np char litery[2]={"A","B"}; wywala błąd. char litery[2]={A,B}; ok ale nie wyświetli nic.

    Chodzi o coś takiego np:
    for (i=1; i<3;i++)
    {
    LCD_WriteText(litery[i]);
    }

    Odnośnie jeszcze tego. Przypuśćmy, że odbieram z przetwornika wartość 156. Jaki jest najszybszy sposób wrzucenia tego na LCD? Jakieś kombimacje z ASCII?

    0
  • #8 06 Paź 2009 20:46
    miszcz310
    Poziom 19  

    Hmmm... Przecież każdy string to jest taka tablica z "literkami" + dodatkowo null na ostatniej pozycji...
    Musisz dokonać konwersji z int do char. Zerknij na funckję itoa z biblioteki stdlib.h W argumentach podajesz liczbę do konwersji, buforek do którego zostanie skopiowany string (Trzeba pamiętać, że bufor musi jeszcze zawsze pomieścić null) i na koniec podajesz podstawę konwersji np.10 (Choć 16 jest przydatna podczas wyświetlania liczb w formacie BDC takich jak np. w RTC typu PCF).

    0
  • #9 06 Paź 2009 20:57
    maly_elektronik
    Poziom 23  

    Tablica może być ale taka:

    Code:

     tablica[2] = {'A', 'B'}; 


    co jest równoznaczne z zapisem:
    Code:

     tablica[2] = {0x41 , 0x42};


    Znak:
    " -> zarezerwowany jest dla stringów :)
    A znak:
    ' -> dla znaków :)



    PS. Wyszło trochę masło maślane ale myśle że przedstawia ideę :]

    0
  • #10 06 Paź 2009 20:59
    sGordon
    Poziom 11  

    revolt napisał:

    Dodano po 3 [godziny] 12 [minuty]:
    W sumie to już mam pytanie :)
    Czy można zdeklarować tablicę liter?
    Np char litery[2]={"A","B"}; wywala błąd. char litery[2]={A,B}; ok ale nie wyświetli nic.

    Chodzi o coś takiego np:
    for (i=1; i<3;i++)
    {
    LCD_WriteText(litery[i]);
    }

    Odnośnie jeszcze tego. Przypuśćmy, że odbieram z przetwornika wartość 156. Jaki jest najszybszy sposób wrzucenia tego na LCD? Jakieś kombimacje z ASCII?


    Po pierwsze deklarując tablicę, jej elementy powinieneś pisać w 'X', a nie "X" np.
    char litery[2]={'A','B'}.

    Po drugie elementy w tablicy numerowane są od zera czyli dla tablicy char litery[2] jej poszczególne elementy mają indeksy 0 i 1. Dlatego pętla for powinna wyglądać tak:
    for (i=0; i<2;i++)
    {
    LCD_WriteText(litery[i]);
    }

    Do zamiany liczby na tablicę czarów musiałbyś napisać funkcję wyznaczającą cyfrę setek, dziesiątek i jedności liczby, a następnie do każdej cyfry dodać liczbę 48 aby uzyskać jej wartość w kodzie ASCII.

    0
  • #11 06 Paź 2009 21:17
    Freddie Chopin
    Specjalista - Mikrokontrolery

    sGordon napisał:
    Do zamiany liczby na tablicę czarów musiałbyś napisać funkcję wyznaczającą cyfrę setek, dziesiątek i jedności liczby, a następnie do każdej cyfry dodać liczbę 48 aby uzyskać jej wartość w kodzie ASCII.

    Ciekawe po co, skoro obecne w avr-libc itoa() robi to samo i na pewno działa...

    4\/3!!

    0
  • #12 09 Lis 2009 23:32
    revolt
    Poziom 34  

    Nie chcę już zakładać nowego tematu:
    czym się różni kwarc 11059200 Hz od 12000000? Ten pierwszy to "typowy" a ja 12000000 wykorzystuje aktualnie do zabaw z UARTem ale nie jest on taki ?popularny? czy te 11 z hakiem jest jakieś charakterystyczne dla pewnych zadań?

    0
  • Pomocny post
    #13 09 Lis 2009 23:57
    M. S.
    Poziom 34  

    11059200Hz daje zerowy błąd transmisji UART. 12MHz zapewni prawidłową transmisję przy mniejszych prędkościach. Przy Baudrate 115200 12MHz się wyłoży (będzie dobre do 28800).

    0
  • #14 17 Lis 2009 21:03
    revolt
    Poziom 34  

    Napisałem sobie takowy program:

    Code:

    #include "stdio.h"
    #include <avr/io.h>
    #include <util/delay.h>
    #include <avr/interrupt.h>
    #define FOSC 12000000
    #define BAUD 9600
    #define MYUBRR FOSC/16/BAUD-1


    SIGNAL(SIG_UART_RECV)
    {
    //USART_Transmit(UDR);
    PORTB=~PORTB;
    _delay_ms(300);
    }

    void USART_Init( unsigned int ubrr)
    {
    UBRRH = (unsigned char)(ubrr>>8);
    UBRRL = (unsigned char)ubrr;
    UCSRB = (1<<RXEN)|(1<<TXEN)|(1<<RXCIE);
    UCSRC = (1<<URSEL)|(1<<USBS)|(3<<UCSZ0);
    }

    void USART_Transmit( unsigned char data )
    {
    while ( !( UCSRA & (1<<UDRE)) );
    UDR = data;
    }

    void main (void)
    {
    USART_Init ( MYUBRR );


    DDRB=0xFF;
    sei();

    while(1)
    {
    }

    }


    O ile w przerwaniu jest //USART_Transmit(UDR); program działa (lub wydaje mi się, że działa) - po wysłaniu czegoś z terminala ładnie odsyła. Natomiast jeżeli chce zapalić/zmienić diodę (dioda pod PB0) to program się zapętla - po wysłaniu pierwszego znaku dioda zaczyna mrugać.

    Uchwyt przerwania zły?

    0
  • #15 18 Lis 2009 15:31
    OldSkull
    Poziom 27  

    Ja nie wiem, co sie ludzie uczepili tych "dziwnych" prędkości transmisji - duże ilości danych i tak nie odbiera/wysyła sie terminalem, tylko zwykłymi aplikacjami, a tam można podać dowolną prędkość (np. 250k), do przesyłu prostych komend nie potrzeba dużych prędkości, 9600 wystarczy, a taką prędkość typowe kwarce obsłużą. Natomiast nietypowe kwarce słabo się nadają do obsługi typowych częstotliwości (np. generowanie sygnału 36kHz, 40kHz czy nawet zwykłe odliczanie krótkich czasów).
    Program wygląda dobrze, nie wiem co jest nie tak.

    0
  • #16 18 Lis 2009 18:30
    revolt
    Poziom 34  

    Nie wiem o czym dokładnie piszesz - prędkość jest 9600 a kwarc 12 zamiast 11059200 jak pisałem wyżej (taki miałem). Ogólnie dopóki nie ma delaya w przerwaniu wszystko działa.

    0
  • #17 29 Lis 2009 21:10
    smiodus
    Poziom 1  

    Witam, podłączę się do tematu bo sam nadałbym mu identyczny tytuł :)

    Po pierwszych powodzeniach z BASCOMem i AVR staram się przestawić na moje natywne środowisko czyli C.

    Mam problem z uruchomieniem LCD. Program napisany w BASCOM'ie i skompilowany działa bez żadnych problemów, w C nie. Kompilacja przechodzi bez zastrzeżeń. Korzystam z biblioteki cytowanego już Peter'a Fleury'ego ( http://homepage.hispeed.ch/peterfleury/avr-software.html ).

    następujący program w BASCOM'ie działa bez problemów

    Code:
    $regfile = "m8def.dat" 
    
    $crystal = 8000000
    Config Lcd = 16 * 2
    Config Lcdpin = Pin , Db4 = Portd.5 , Db5 = Portd.6 , Db6 = Portd.7 , Db7 = Portd.4 , E = Portd.3 , Rs = Portd.2

    Cls
    Lcd "test"
    End


    plik lcd.h z biblioteki zmieniłem mniej więcej tak:

    Code:

    #define XTAL 8000000

    #define LCD_PORT         PORTD        /**< port for the LCD lines   */
    #define LCD_DATA0_PORT   LCD_PORT     /**< port for 4bit data bit 0 */
    #define LCD_DATA1_PORT   LCD_PORT     /**< port for 4bit data bit 1 */
    #define LCD_DATA2_PORT   LCD_PORT     /**< port for 4bit data bit 2 */
    #define LCD_DATA3_PORT   LCD_PORT     /**< port for 4bit data bit 3 */
    #define LCD_DATA0_PIN    5            /**< pin for 4bit data bit 0  */
    #define LCD_DATA1_PIN    6            /**< pin for 4bit data bit 1  */
    #define LCD_DATA2_PIN    7            /**< pin for 4bit data bit 2  */
    #define LCD_DATA3_PIN    4            /**< pin for 4bit data bit 3  */
    #define LCD_RS_PORT      LCD_PORT     /**< port for RS line         */
    #define LCD_RS_PIN       2            /**< pin  for RS line         */
    #define LCD_RW_PORT      LCD_PORT     /**< port for RW line         */
    #define LCD_RW_PIN       1            /**< pin  for RW line         */
    #define LCD_E_PORT       LCD_PORT     /**< port for Enable line     */
    #define LCD_E_PIN        3            /**< pin  for Enable line     */


    dodam tylko że fizycznie PIN R/W mam podłączony do masy, i nie za bardzo wiedziałem co wpisać w tym miejscu,

    efekt jest 1 rząd (górny) czarnych kwadratów na LCD.

    Pomóżcie bo już 3 dzień to katuje i powoli zaczynam siwieć.

    dzięki i pozdrawiam
    S

    0
  • #18 29 Lis 2009 21:23
    revolt
    Poziom 34  

    No podejrzewam, że te 1,2,3... nie pasuję coś. Przytoczę kawałek mojego kodu:
    #define LCD_RS_DIR DDRD
    #define LCD_RS_PORT PORTD
    #define LCD_RS_PIN PIND
    #define LCD_RS (1 << PD3)

    Czyli zamiast
    #define LCD_DATA0_PIN 5
    spróbuj
    #define LCD_DATA0_PIN PD5

    0
  • #19 29 Lis 2009 21:44
    DonQuijote88
    Poziom 13  

    Kolego revolt mam ten sam problem. Spróbuj skopiować źródło HD44780.c do pliku z programem głównym i odpalić. U mnie w taki sposób działa, natomiast po dołączeniu przez nagłówek objawy są podobne.

    0