logo elektroda
logo elektroda
X
logo elektroda
REKLAMA
REKLAMA
Adblock/uBlockOrigin/AdGuard mogą powodować znikanie niektórych postów z powodu nowej reguły.

ERROR w AVR STUDIO po dodaniu biblioteki

Rafał_ 26 Sie 2010 18:34 2436 8
REKLAMA
  • #1 8441652
    Rafał_
    Poziom 10  
    Witam ,

    Mam problem , po dodaniu biblioteki do projektu w programie AVR Studio wyskakuje mi Error i nie bardzo wiem o co chodzi :/ jeśli mógłby mi ktoś coś doradzić będę wdzięczny ... pozdrawiam
    Cytat:
    rm -rf projekt.o projekt.elf dep/* projekt.hex projekt.eep projekt.lss projekt.map
    Build succeeded with 0 Warnings...
    avr-gcc -mmcu=atmega8 -Wall -gdwarf-2 -Os -std=gnu99 -funsigned-char -funsigned-bitfields -fpack-struct -fshort-enums -MD -MP -MT projekt.o -MF dep/projekt.o.d -c ../projekt.c
    avr-gcc -mmcu=atmega8 -Wall -gdwarf-2 -Os -std=gnu99 -funsigned-char -funsigned-bitfields -fpack-struct -fshort-enums -MD -MP -MT lcd.o -MF dep/lcd.o.d -c ../lcd.c
    avr-gcc -mmcu=atmega8 -Wl,-Map=projekt.map projekt.o lcd.o -o projekt.elf
    lcd.o: In function `lcd_command':
    C:\Documents and Settings\Mefisto\Pulpit\Nowy folder\default/../lcd.c:336: multiple definition of `lcd_command'
    projekt.o:C:\Documents and Settings\Mefisto\Pulpit\Nowy folder\default/../lcd.c:336: first defined here
    lcd.o: In function `lcd_data':
    C:\Documents and Settings\Mefisto\Pulpit\Nowy folder\default/../lcd.c:348: multiple definition of `lcd_data'
    projekt.o:C:\Documents and Settings\Mefisto\Pulpit\Nowy folder\default/../lcd.c:348: first defined here
    lcd.o: In function `lcd_gotoxy':
    C:\Documents and Settings\Mefisto\Pulpit\Nowy folder\default/../lcd.c:367: multiple definition of `lcd_gotoxy'
    projekt.o:C:\Documents and Settings\Mefisto\Pulpit\Nowy folder\default/../lcd.c:367: first defined here
    lcd.o: In function `lcd_getxy':
    C:\Documents and Settings\Mefisto\Pulpit\Nowy folder\default/../lcd.c:390: multiple definition of `lcd_getxy'
    projekt.o:C:\Documents and Settings\Mefisto\Pulpit\Nowy folder\default/../lcd.c:390: first defined here
    lcd.o: In function `lcd_clrscr':
    C:\Documents and Settings\Mefisto\Pulpit\Nowy folder\default/../lcd.c:399: multiple definition of `lcd_clrscr'
    projekt.o:C:\Documents and Settings\Mefisto\Pulpit\Nowy folder\default/../lcd.c:399: first defined here
    lcd.o: In function `lcd_home':
    C:\Documents and Settings\Mefisto\Pulpit\Nowy folder\default/../lcd.c:408: multiple definition of `lcd_home'
    projekt.o:C:\Documents and Settings\Mefisto\Pulpit\Nowy folder\default/../lcd.c:408: first defined here
    lcd.o: In function `lcd_putc':
    C:\Documents and Settings\Mefisto\Pulpit\Nowy folder\default/../lcd.c:418: multiple definition of `lcd_putc'
    projekt.o:C:\Documents and Settings\Mefisto\Pulpit\Nowy folder\default/../lcd.c:418: first defined here
    lcd.o: In function `lcd_puts':
    C:\Documents and Settings\Mefisto\Pulpit\Nowy folder\default/../lcd.c:463: multiple definition of `lcd_puts'
    projekt.o:C:\Documents and Settings\Mefisto\Pulpit\Nowy folder\default/../lcd.c:463: first defined here
    lcd.o: In function `lcd_puts_p':
    C:\Documents and Settings\Mefisto\Pulpit\Nowy folder\default/../lcd.c:480: multiple definition of `lcd_puts_p'
    projekt.o:C:\Documents and Settings\Mefisto\Pulpit\Nowy folder\default/../lcd.c:480: first defined here
    lcd.o: In function `lcd_init':
    C:\Documents and Settings\Mefisto\Pulpit\Nowy folder\default/../lcd.c:499: multiple definition of `lcd_init'
    projekt.o:C:\Documents and Settings\Mefisto\Pulpit\Nowy folder\default/../lcd.c:499: first defined here
    make: *** [projekt.elf] Error 1
    Build failed with 1 errors and 0 warnings...
  • REKLAMA
  • #2 8441693
    gaskoin
    Poziom 38  
    pokaż kod programu i makefile
  • REKLAMA
  • #3 8441706
    Rafał_
    Poziom 10  
    makefile

    Cytat:
    ###############################################################################
    # Makefile for the project projekt
    ###############################################################################

    ## General Flags
    PROJECT = projekt
    MCU = atmega8
    TARGET = projekt.elf
    CC = avr-gcc

    ## Options common to compile, link and assembly rules
    COMMON = -mmcu=$(MCU)

    ## Compile options common for all C compilation units.
    CFLAGS = $(COMMON)
    CFLAGS += -Wall -gdwarf-2 -Os -std=gnu99 -funsigned-char -funsigned-bitfields -fpack-struct -fshort-enums
    CFLAGS += -MD -MP -MT $(*F).o -MF dep/$(@F).d

    ## Assembly specific flags
    ASMFLAGS = $(COMMON)
    ASMFLAGS += $(CFLAGS)
    ASMFLAGS += -x assembler-with-cpp -Wa,-gdwarf2

    ## Linker flags
    LDFLAGS = $(COMMON)
    LDFLAGS += -Wl,-Map=projekt.map


    ## Intel Hex file production flags
    HEX_FLASH_FLAGS = -R .eeprom -R .fuse -R .lock -R .signature

    HEX_EEPROM_FLAGS = -j .eeprom
    HEX_EEPROM_FLAGS += --set-section-flags=.eeprom="alloc,load"
    HEX_EEPROM_FLAGS += --change-section-lma .eeprom=0 --no-change-warnings


    ## Objects that must be built in order to link
    OBJECTS = projekt.o lcd.o

    ## Objects explicitly added by the user
    LINKONLYOBJECTS =

    ## Build
    all: $(TARGET) projekt.hex projekt.eep projekt.lss size

    ## Compile
    projekt.o: ../projekt.c
    $(CC) $(INCLUDES) $(CFLAGS) -c $<

    lcd.o: ../lcd.c
    $(CC) $(INCLUDES) $(CFLAGS) -c $<

    ##Link
    $(TARGET): $(OBJECTS)
    $(CC) $(LDFLAGS) $(OBJECTS) $(LINKONLYOBJECTS) $(LIBDIRS) $(LIBS) -o $(TARGET)

    %.hex: $(TARGET)
    avr-objcopy -O ihex $(HEX_FLASH_FLAGS) $< $@

    %.eep: $(TARGET)
    -avr-objcopy $(HEX_EEPROM_FLAGS) -O ihex $< $@ || exit 0

    %.lss: $(TARGET)
    avr-objdump -h -S $< > $@

    size: ${TARGET}
    @Echo.
    @AVR-size -C --mcu=${MCU} ${TARGET}

    ## Clean target
    .PHONY: clean
    clean:
    -rm -rf $(OBJECTS) projekt.elf dep/* projekt.hex projekt.eep projekt.lss projekt.map


    ## Other dependencies
    -include $(shell mkdir dep 2>/dev/null) $(wildcard dep/*)



    bibliotek pobrana z sieci lcd.h
    /****************************************************************************
     Title	:   HD44780U LCD library
     Author:    Peter Fleury <pfleury@gmx.ch>  http://jump.to/fleury
     File:	    $Id: lcd.c,v 1.13.2.5 2005/02/16 19:15:13 Peter Exp $
     Software:  AVR-GCC 3.3 
     Target:    any AVR device, memory mapped mode only for AT90S4414/8515/Mega
    
     DESCRIPTION
           Basic routines for interfacing a HD44780U-based text lcd display
    
           Originally based on Volker Oth's lcd library,
           changed lcd_init(), added additional constants for lcd_command(),
           added 4-bit I/O mode, improved and optimized code.
    
           Library can be operated in memory mapped mode (LCD_IO_MODE=0) or in 
           4-bit IO port mode (LCD_IO_MODE=1). 8-bit IO port mode not supported.
           
           Memory mapped mode compatible with Kanda STK200, but supports also
           generation of R/W signal through A8 address line.
    
     USAGE
           See the C include lcd.h file for a description of each function
           
    *****************************************************************************/
    #include <inttypes.h>
    #include <avr/io.h>
    #include <avr/pgmspace.h>
    #include "lcd.h"
    
    
    
    /* 
    ** constants/macros 
    */
    #define DDR(x) (*(&x - 1))      /* address of data direction register of port x */
    #if defined(__AVR_ATmega64__) || defined(__AVR_ATmega128__)
        /* on ATmega64/128 PINF is on port 0x00 and not 0x60 */
        #define PIN(x) ( &PORTF==&(x) ? _SFR_IO8(0x00) : (*(&x - 2)) )
    #else
    	#define PIN(x) (*(&x - 2))    /* address of input register of port x          */
    #endif
    
    
    #if LCD_IO_MODE
    #define lcd_e_delay()   __asm__ __volatile__( "rjmp 1f\n 1:" );
    #define lcd_e_high()    LCD_E_PORT  |=  _BV(LCD_E_PIN);
    #define lcd_e_low()     LCD_E_PORT  &= ~_BV(LCD_E_PIN);
    #define lcd_e_toggle()  toggle_e()
    #define lcd_rw_high()   LCD_RW_PORT |=  _BV(LCD_RW_PIN)
    #define lcd_rw_low()    LCD_RW_PORT &= ~_BV(LCD_RW_PIN)
    #define lcd_rs_high()   LCD_RS_PORT |=  _BV(LCD_RS_PIN)
    #define lcd_rs_low()    LCD_RS_PORT &= ~_BV(LCD_RS_PIN)
    #endif
    
    #if LCD_IO_MODE
    #if LCD_LINES==1
    #define LCD_FUNCTION_DEFAULT    LCD_FUNCTION_4BIT_1LINE 
    #else
    #define LCD_FUNCTION_DEFAULT    LCD_FUNCTION_4BIT_2LINES 
    #endif
    #else
    #if LCD_LINES==1
    #define LCD_FUNCTION_DEFAULT    LCD_FUNCTION_8BIT_1LINE
    #else
    #define LCD_FUNCTION_DEFAULT    LCD_FUNCTION_8BIT_2LINES
    #endif
    #endif
    
    
    /* 
    ** function prototypes 
    */
    #if LCD_IO_MODE
    static void toggle_e(void);
    #endif
    
    /*
    ** local functions
    */
    
    
    
    /*************************************************************************
     delay loop for small accurate delays: 16-bit counter, 4 cycles/loop
    *************************************************************************/
    static inline void _delayFourCycles(unsigned int __count)
    {
        if ( __count == 0 )    
            __asm__ __volatile__( "rjmp 1f\n 1:" );    // 2 cycles
        else
            __asm__ __volatile__ (
        	    "1: sbiw %0,1" "\n\t"                  
        	    "brne 1b"                              // 4 cycles/loop
        	    : "=w" (__count)
        	    : "0" (__count)
        	   );
    }
    
    
    /************************************************************************* 
    delay for a minimum of <us> microseconds
    the number of loops is calculated at compile-time from MCU clock frequency
    *************************************************************************/
    #define delay(us)  _delayFourCycles( ( ( 1*(XTAL/4000) )*us)/1000 )
    
    
    #if LCD_IO_MODE
    /* toggle Enable Pin to initiate write */
    static void toggle_e(void)
    {
        lcd_e_high();
        lcd_e_delay();
        lcd_e_low();
    }
    #endif
    
    
    /*************************************************************************
    Low-level function to write byte to LCD controller
    Input:    data   byte to write to LCD
              rs     1: write data    
                     0: write instruction
    Returns:  none
    *************************************************************************/
    #if LCD_IO_MODE
    static void lcd_write(uint8_t data,uint8_t rs) 
    {
        unsigned char dataBits ;
    
    
        if (rs) {   /* write data        (RS=1, RW=0) */
           lcd_rs_high();
        } else {    /* write instruction (RS=0, RW=0) */
           lcd_rs_low();
        }
        lcd_rw_low();
    
        if ( ( &LCD_DATA0_PORT == &LCD_DATA1_PORT) && ( &LCD_DATA1_PORT == &LCD_DATA2_PORT ) && ( &LCD_DATA2_PORT == &LCD_DATA3_PORT )
          && (LCD_DATA0_PIN == 0) && (LCD_DATA1_PIN == 1) && (LCD_DATA2_PIN == 2) && (LCD_DATA3_PIN == 3) )
        {
            /* configure data pins as output */
            DDR(LCD_DATA0_PORT) |= 0x0F;
    
            /* output high nibble first */
            dataBits = LCD_DATA0_PORT & 0xF0;
            LCD_DATA0_PORT = dataBits |((data>>4)&0x0F);
            lcd_e_toggle();
    
            /* output low nibble */
            LCD_DATA0_PORT = dataBits | (data&0x0F);
            lcd_e_toggle();
    
            /* all data pins high (inactive) */
            LCD_DATA0_PORT = dataBits | 0x0F;
        }
        else
        {
            /* configure data pins as output */
            DDR(LCD_DATA0_PORT) |= _BV(LCD_DATA0_PIN);
            DDR(LCD_DATA1_PORT) |= _BV(LCD_DATA1_PIN);
            DDR(LCD_DATA2_PORT) |= _BV(LCD_DATA2_PIN);
            DDR(LCD_DATA3_PORT) |= _BV(LCD_DATA3_PIN);
            
            /* output high nibble first */
            LCD_DATA3_PORT &= ~_BV(LCD_DATA3_PIN);
            LCD_DATA2_PORT &= ~_BV(LCD_DATA2_PIN);
            LCD_DATA1_PORT &= ~_BV(LCD_DATA1_PIN);
            LCD_DATA0_PORT &= ~_BV(LCD_DATA0_PIN);
        	if(data & 0x80) LCD_DATA3_PORT |= _BV(LCD_DATA3_PIN);
        	if(data & 0x40) LCD_DATA2_PORT |= _BV(LCD_DATA2_PIN);
        	if(data & 0x20) LCD_DATA1_PORT |= _BV(LCD_DATA1_PIN);
        	if(data & 0x10) LCD_DATA0_PORT |= _BV(LCD_DATA0_PIN);   
            lcd_e_toggle();
            
            /* output low nibble */
            LCD_DATA3_PORT &= ~_BV(LCD_DATA3_PIN);
            LCD_DATA2_PORT &= ~_BV(LCD_DATA2_PIN);
            LCD_DATA1_PORT &= ~_BV(LCD_DATA1_PIN);
            LCD_DATA0_PORT &= ~_BV(LCD_DATA0_PIN);
        	if(data & 0x08) LCD_DATA3_PORT |= _BV(LCD_DATA3_PIN);
        	if(data & 0x04) LCD_DATA2_PORT |= _BV(LCD_DATA2_PIN);
        	if(data & 0x02) LCD_DATA1_PORT |= _BV(LCD_DATA1_PIN);
        	if(data & 0x01) LCD_DATA0_PORT |= _BV(LCD_DATA0_PIN);
            lcd_e_toggle();        
            
            /* all data pins high (inactive) */
            LCD_DATA0_PORT |= _BV(LCD_DATA0_PIN);
            LCD_DATA1_PORT |= _BV(LCD_DATA1_PIN);
            LCD_DATA2_PORT |= _BV(LCD_DATA2_PIN);
            LCD_DATA3_PORT |= _BV(LCD_DATA3_PIN);
        }
    }
    #else
    #define lcd_write(d,rs) if (rs) *(volatile uint8_t*)(LCD_IO_DATA) = d; else *(volatile uint8_t*)(LCD_IO_FUNCTION) = d;
    /* rs==0 -> write instruction to LCD_IO_FUNCTION */
    /* rs==1 -> write data to LCD_IO_DATA */
    #endif
    
    
    /*************************************************************************
    Low-level function to read byte from LCD controller
    Input:    rs     1: read data    
                     0: read busy flag / address counter
    Returns:  byte read from LCD controller
    *************************************************************************/
    #if LCD_IO_MODE
    static uint8_t lcd_read(uint8_t rs) 
    {
        uint8_t data;
        
        
        if (rs)
            lcd_rs_high();                       /* RS=1: read data      */
        else
            lcd_rs_low();                        /* RS=0: read busy flag */
        lcd_rw_high();                           /* RW=1  read mode      */
        
        if ( ( &LCD_DATA0_PORT == &LCD_DATA1_PORT) && ( &LCD_DATA1_PORT == &LCD_DATA2_PORT ) && ( &LCD_DATA2_PORT == &LCD_DATA3_PORT )
          && ( LCD_DATA0_PIN == 0 )&& (LCD_DATA1_PIN == 1) && (LCD_DATA2_PIN == 2) && (LCD_DATA3_PIN == 3) )
        {
            DDR(LCD_DATA0_PORT) &= 0xF0;         /* configure data pins as input */
            
            lcd_e_high();
            lcd_e_delay();        
            data = PIN(LCD_DATA0_PORT) << 4;     /* read high nibble first */
            lcd_e_low();
            
            lcd_e_delay();                       /* Enable 500ns low       */
            
            lcd_e_high();
            lcd_e_delay();
            data |= PIN(LCD_DATA0_PORT)&0x0F;    /* read low nibble        */
            lcd_e_low();
        }
        else
        {
            /* configure data pins as input */
            DDR(LCD_DATA0_PORT) &= ~_BV(LCD_DATA0_PIN);
            DDR(LCD_DATA1_PORT) &= ~_BV(LCD_DATA1_PIN);
            DDR(LCD_DATA2_PORT) &= ~_BV(LCD_DATA2_PIN);
            DDR(LCD_DATA3_PORT) &= ~_BV(LCD_DATA3_PIN);
                    
            /* read high nibble first */
            lcd_e_high();
            lcd_e_delay();        
            data = 0;
            if ( PIN(LCD_DATA0_PORT) & _BV(LCD_DATA0_PIN) ) data |= 0x10;
            if ( PIN(LCD_DATA1_PORT) & _BV(LCD_DATA1_PIN) ) data |= 0x20;
            if ( PIN(LCD_DATA2_PORT) & _BV(LCD_DATA2_PIN) ) data |= 0x40;
            if ( PIN(LCD_DATA3_PORT) & _BV(LCD_DATA3_PIN) ) data |= 0x80;
            lcd_e_low();
    
            lcd_e_delay();                       /* Enable 500ns low       */
        
            /* read low nibble */    
            lcd_e_high();
            lcd_e_delay();
            if ( PIN(LCD_DATA0_PORT) & _BV(LCD_DATA0_PIN) ) data |= 0x01;
            if ( PIN(LCD_DATA1_PORT) & _BV(LCD_DATA1_PIN) ) data |= 0x02;
            if ( PIN(LCD_DATA2_PORT) & _BV(LCD_DATA2_PIN) ) data |= 0x04;
            if ( PIN(LCD_DATA3_PORT) & _BV(LCD_DATA3_PIN) ) data |= 0x08;        
            lcd_e_low();
        }
        return data;
    }
    #else
    #define lcd_read(rs) (rs) ? *(volatile uint8_t*)(LCD_IO_DATA+LCD_IO_READ) : *(volatile uint8_t*)(LCD_IO_FUNCTION+LCD_IO_READ)
    /* rs==0 -> read instruction from LCD_IO_FUNCTION */
    /* rs==1 -> read data from LCD_IO_DATA */
    #endif
    
    
    /*************************************************************************
    loops while lcd is busy, returns address counter
    *************************************************************************/
    static uint8_t lcd_waitbusy(void)
    
    {
        register uint8_t c;
        
        /* wait until busy flag is cleared */
        while ( (c=lcd_read(0)) & (1<<LCD_BUSY)) {}
        
        /* the address counter is updated 4us after the busy flag is cleared */
        delay(2);
    
        /* now read the address counter */
        return (lcd_read(0));  // return address counter
        
    }/* lcd_waitbusy */
    
    
    /*************************************************************************
    Move cursor to the start of next line or to the first line if the cursor 
    is already on the last line.
    *************************************************************************/
    static inline void lcd_newline(uint8_t pos)
    {
        register uint8_t addressCounter;
    
    
    #if LCD_LINES==1
        addressCounter = 0;
    #endif
    #if LCD_LINES==2
        if ( pos < (LCD_START_LINE2) )
            addressCounter = LCD_START_LINE2;
        else
            addressCounter = LCD_START_LINE1;
    #endif
    #if LCD_LINES==4
        if ( pos < LCD_START_LINE3 )
            addressCounter = LCD_START_LINE2;
        else if ( (pos >= LCD_START_LINE2) && (pos < LCD_START_LINE4) )
            addressCounter = LCD_START_LINE3;
        else if ( (pos >= LCD_START_LINE3) && (pos < LCD_START_LINE2) )
            addressCounter = LCD_START_LINE4;
        else 
            addressCounter = LCD_START_LINE1;
    #endif
        lcd_command((1<<LCD_DDRAM)+addressCounter);
    
    }/* lcd_newline */
    
    
    /*
    ** PUBLIC FUNCTIONS 
    */
    
    /*************************************************************************
    Send LCD controller instruction command
    Input:   instruction to send to LCD controller, see HD44780 data sheet
    Returns: none
    *************************************************************************/
    void lcd_command(uint8_t cmd)
    {
        lcd_waitbusy();
        lcd_write(cmd,0);
    }
    
    
    /*************************************************************************
    Send data byte to LCD controller 
    Input:   data to send to LCD controller, see HD44780 data sheet
    Returns: none
    *************************************************************************/
    void lcd_data(uint8_t data)
    {
        lcd_waitbusy();
        lcd_write(data,1);
    }
    
    
    
    /*************************************************************************
    Set cursor to specified position
    Input:    x  horizontal position  (0: left most position)
              y  vertical position    (0: first line)
    Returns:  none
    *************************************************************************/
    void lcd_gotoxy(uint8_t x, uint8_t y)
    {
    #if LCD_LINES==1
        lcd_command((1<<LCD_DDRAM)+LCD_START_LINE1+x);
    #endif
    #if LCD_LINES==2
        if ( y==0 ) 
            lcd_command((1<<LCD_DDRAM)+LCD_START_LINE1+x);
        else
            lcd_command((1<<LCD_DDRAM)+LCD_START_LINE2+x);
    #endif
    #if LCD_LINES==4
        if ( y==0 )
            lcd_command((1<<LCD_DDRAM)+LCD_START_LINE1+x);
        else if ( y==1)
            lcd_command((1<<LCD_DDRAM)+LCD_START_LINE2+x);
        else if ( y==2)
            lcd_command((1<<LCD_DDRAM)+LCD_START_LINE3+x);
        else /* y==3 */
            lcd_command((1<<LCD_DDRAM)+LCD_START_LINE4+x);
    #endif
    
    }/* lcd_gotoxy */
    
    
    /*************************************************************************
    *************************************************************************/
    int lcd_getxy(void)
    {
        return lcd_waitbusy();
    }
    
    
    /*************************************************************************
    Clear display and set cursor to home position
    *************************************************************************/
    void lcd_clrscr(void)
    {
        lcd_command(1<<LCD_CLR);
    }
    
    
    /*************************************************************************
    Set cursor to home position
    *************************************************************************/
    void lcd_home(void)
    {
        lcd_command(1<<LCD_HOME);
    }
    
    
    /*************************************************************************
    Display character at current cursor position 
    Input:    character to be displayed                                       
    Returns:  none
    *************************************************************************/
    void lcd_putc(char c)
    {
        uint8_t pos;
    
    
        pos = lcd_waitbusy();   // read busy-flag and address counter
        if (c=='\n')
        {
            lcd_newline(pos);
        }
        else
        {
    #if LCD_WRAP_LINES==1
    #if LCD_LINES==1
            if ( pos == LCD_START_LINE1+LCD_DISP_LENGTH )
                lcd_write((1<<LCD_DDRAM)+LCD_START_LINE1,0);
    #elif LCD_LINES==2
            if ( pos == LCD_START_LINE1+LCD_DISP_LENGTH )
                lcd_write((1<<LCD_DDRAM)+LCD_START_LINE2,0);    
            else if ( pos == LCD_START_LINE2+LCD_DISP_LENGTH )
                lcd_write((1<<LCD_DDRAM)+LCD_START_LINE1,0);
    #elif LCD_LINES==4
            if ( pos == LCD_START_LINE1+LCD_DISP_LENGTH )
                lcd_write((1<<LCD_DDRAM)+LCD_START_LINE2,0);    
            else if ( pos == LCD_START_LINE2+LCD_DISP_LENGTH )
                lcd_write((1<<LCD_DDRAM)+LCD_START_LINE3,0);
            else if ( pos == LCD_START_LINE3+LCD_DISP_LENGTH )
                lcd_write((1<<LCD_DDRAM)+LCD_START_LINE4,0);
            else if ( pos == LCD_START_LINE4+LCD_DISP_LENGTH )
                lcd_write((1<<LCD_DDRAM)+LCD_START_LINE1,0);
    #endif
            lcd_waitbusy();
    #endif
            lcd_write(c, 1);
        }
    
    }/* lcd_putc */
    
    
    /*************************************************************************
    Display string without auto linefeed 
    Input:    string to be displayed
    Returns:  none
    *************************************************************************/
    void lcd_puts(const char *s)
    /* print string on lcd (no auto linefeed) */
    {
        register char c;
    
        while ( (c = *s++) ) {
            lcd_putc(c);
        }
    
    }/* lcd_puts */
    
    
    /*************************************************************************
    Display string from program memory without auto linefeed 
    Input:     string from program memory be be displayed                                        
    Returns:   none
    *************************************************************************/
    void lcd_puts_p(const char *progmem_s)
    /* print string from program memory on lcd (no auto linefeed) */
    {
        register char c;
    
        while ( (c = pgm_read_byte(progmem_s++)) ) {
            lcd_putc(c);
        }
    
    }/* lcd_puts_p */
    
    
    /*************************************************************************
    Initialize display and select type of cursor 
    Input:    dispAttr LCD_DISP_OFF            display off
                       LCD_DISP_ON             display on, cursor off
                       LCD_DISP_ON_CURSOR      display on, cursor on
                       LCD_DISP_CURSOR_BLINK   display on, cursor on flashing
    Returns:  none
    *************************************************************************/
    void lcd_init(uint8_t dispAttr)
    {
    #if LCD_IO_MODE
        /*
         *  Initialize LCD to 4 bit I/O mode
         */
         
        if ( ( &LCD_DATA0_PORT == &LCD_DATA1_PORT) && ( &LCD_DATA1_PORT == &LCD_DATA2_PORT ) && ( &LCD_DATA2_PORT == &LCD_DATA3_PORT )
          && ( &LCD_RS_PORT == &LCD_DATA0_PORT) && ( &LCD_RW_PORT == &LCD_DATA0_PORT) && (&LCD_E_PORT == &LCD_DATA0_PORT)
          && (LCD_DATA0_PIN == 0 ) && (LCD_DATA1_PIN == 1) && (LCD_DATA2_PIN == 2) && (LCD_DATA3_PIN == 3) 
          && (LCD_RS_PIN == 4 ) && (LCD_RW_PIN == 5) && (LCD_E_PIN == 6 ) )
        {
            /* configure all port bits as output (all LCD lines on same port) */
            DDR(LCD_DATA0_PORT) |= 0x7F;
        }
        else if ( ( &LCD_DATA0_PORT == &LCD_DATA1_PORT) && ( &LCD_DATA1_PORT == &LCD_DATA2_PORT ) && ( &LCD_DATA2_PORT == &LCD_DATA3_PORT )
               && (LCD_DATA0_PIN == 0 ) && (LCD_DATA1_PIN == 1) && (LCD_DATA2_PIN == 2) && (LCD_DATA3_PIN == 3) )
        {
            /* configure all port bits as output (all LCD data lines on same port, but control lines on different ports) */
            DDR(LCD_DATA0_PORT) |= 0x0F;
            DDR(LCD_RS_PORT)    |= _BV(LCD_RS_PIN);
            DDR(LCD_RW_PORT)    |= _BV(LCD_RW_PIN);
            DDR(LCD_E_PORT)     |= _BV(LCD_E_PIN);
        }
        else
        {
            /* configure all port bits as output (LCD data and control lines on different ports */
            DDR(LCD_RS_PORT)    |= _BV(LCD_RS_PIN);
            DDR(LCD_RW_PORT)    |= _BV(LCD_RW_PIN);
            DDR(LCD_E_PORT)     |= _BV(LCD_E_PIN);
            DDR(LCD_DATA0_PORT) |= _BV(LCD_DATA0_PIN);
            DDR(LCD_DATA1_PORT) |= _BV(LCD_DATA1_PIN);
            DDR(LCD_DATA2_PORT) |= _BV(LCD_DATA2_PIN);
            DDR(LCD_DATA3_PORT) |= _BV(LCD_DATA3_PIN);
        }
        delay(16000);        /* wait 16ms or more after power-on       */
        
        /* initial write to lcd is 8bit */
        LCD_DATA1_PORT |= _BV(LCD_DATA1_PIN);  // _BV(LCD_FUNCTION)>>4;
        LCD_DATA0_PORT |= _BV(LCD_DATA0_PIN);  // _BV(LCD_FUNCTION_8BIT)>>4;
        lcd_e_toggle();
        delay(4992);         /* delay, busy flag can't be checked here */
       
        /* repeat last command */ 
        lcd_e_toggle();      
        delay(64);           /* delay, busy flag can't be checked here */
        
        /* repeat last command a third time */
        lcd_e_toggle();      
        delay(64);           /* delay, busy flag can't be checked here */
    
        /* now configure for 4bit mode */
        LCD_DATA0_PORT &= ~_BV(LCD_DATA0_PIN);   // LCD_FUNCTION_4BIT_1LINE>>4
        lcd_e_toggle();
        delay(64);           /* some displays need this additional delay */
        
        /* from now the LCD only accepts 4 bit I/O, we can use lcd_command() */    
    #else
        /*
         * Initialize LCD to 8 bit memory mapped mode
         */
        
        /* enable external SRAM (memory mapped lcd) and one wait state */        
        MCUCR = _BV(SRE) | _BV(SRW);
    
        /* reset LCD */
        delay(16000);                           /* wait 16ms after power-on     */
        lcd_write(LCD_FUNCTION_8BIT_1LINE,0);   /* function set: 8bit interface */                   
        delay(4992);                            /* wait 5ms                     */
        lcd_write(LCD_FUNCTION_8BIT_1LINE,0);   /* function set: 8bit interface */                 
        delay(64);                              /* wait 64us                    */
        lcd_write(LCD_FUNCTION_8BIT_1LINE,0);   /* function set: 8bit interface */                
        delay(64);                              /* wait 64us                    */
    #endif
        lcd_command(LCD_FUNCTION_DEFAULT);      /* function set: display lines  */
        lcd_command(LCD_DISP_OFF);              /* display off                  */
        lcd_clrscr();                           /* display clear                */ 
        lcd_command(LCD_MODE_DEFAULT);          /* set entry mode               */
        lcd_command(dispAttr);                  /* display/cursor control       */
    
    }/* lcd_init */
    
  • REKLAMA
  • #4 8441730
    Andrzej__S
    Poziom 28  
    To mi bardziej wygląda na "lcd.c", a nie "lcd.h"
  • REKLAMA
  • #5 8441749
    Rafał_
    Poziom 10  
    tak , masz rację to jest lcd.c

    lcd.h :

    #ifndef LCD_H
    #define LCD_H
    /*************************************************************************
     Title	:   C include file for the HD44780U LCD library (lcd.c)
     Author:    Peter Fleury <pfleury@gmx.ch>  http://jump.to/fleury
     File:	    $Id: lcd.h,v 1.12.2.4 2005/02/28 22:54:41 Peter Exp $
     Software:  AVR-GCC 3.3
     Hardware:  any AVR device, memory mapped mode only for AT90S4414/8515/Mega
    ***************************************************************************/
    
    /**
     @defgroup pfleury_lcd LCD library
     @code #include <lcd.h> @endcode
     
     @brief Basic routines for interfacing a HD44780U-based text LCD display
    
     Originally based on Volker Oth's LCD library,
     changed lcd_init(), added additional constants for lcd_command(), 
     added 4-bit I/O mode, improved and optimized code.
           
     Library can be operated in memory mapped mode (LCD_IO_MODE=0) or in 
     4-bit IO port mode (LCD_IO_MODE=1). 8-bit IO port mode not supported.
    
     Memory mapped mode compatible with Kanda STK200, but supports also 
     generation of R/W signal through A8 address line.
           
     @author Peter Fleury pfleury@gmx.ch http://jump.to/fleury
     
     @see The chapter <a href="http://homepage.sunrise.ch/mysunrise/peterfleury/avr-lcd44780.html" target="_blank">Interfacing a HD44780 Based LCD to an AVR</a>
          on my home page.
    
    */
    
    /*@{*/
    
    #if (__GNUC__ * 100 + __GNUC_MINOR__) < 303
    #error "This library requires AVR-GCC 3.3 or later, update to newer AVR-GCC compiler !"
    #endif
    
    #include <inttypes.h>
    #include <avr/pgmspace.h>
    
    /** 
     *  @name  Definitions for MCU Clock Frequency
     *  Adapt the MCU clock frequency in Hz to your target. 
     */
    #define XTAL 8000000              /**< clock frequency in Hz, used to calculate delay timer */
    
    /** 
     *  @name  Definitions for Display Size 
     *  Change these definitions to adapt setting to your display
     */
    #define LCD_LINES           2     /**< number of visible lines of the display */
    #define LCD_DISP_LENGTH    16     /**< visibles characters per line of the display */
    #define LCD_LINE_LENGTH  0x40     /**< internal line length of the display    */
    #define LCD_START_LINE1  0x00     /**< DDRAM address of first char of line 1 */
    #define LCD_START_LINE2  0x40     /**< DDRAM address of first char of line 2 */
    #define LCD_START_LINE3  0x14     /**< DDRAM address of first char of line 3 */
    #define LCD_START_LINE4  0x54     /**< DDRAM address of first char of line 4 */
    #define LCD_WRAP_LINES      0     /**< 0: no wrap, 1: wrap at end of visibile line */
    
    
    #define LCD_IO_MODE      1         /**< 0: memory mapped mode, 1: IO port mode */
    #if LCD_IO_MODE
    /**
     *  @name Definitions for 4-bit IO mode
     *  Change LCD_PORT if you want to use a different port for the LCD pins.
     *
     *  The four LCD data lines and the three control lines RS, RW, E can be on the 
     *  same port or on different ports. 
     *  Change LCD_RS_PORT, LCD_RW_PORT, LCD_E_PORT if you want the control lines on
     *  different ports. 
     *
     *  Normally the four data lines should be mapped to bit 0..3 on one port, but it
     *  is possible to connect these data lines in different order or even on different
     *  ports by adapting the LCD_DATAx_PORT and LCD_DATAx_PIN definitions.
     *  
     */
    #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    4           /**< pin for 4bit data bit 0  */
    #define LCD_DATA1_PIN    5            /**< pin for 4bit data bit 1  */
    #define LCD_DATA2_PIN    6           /**< pin for 4bit data bit 2  */
    #define LCD_DATA3_PIN    7           /**< pin for 4bit data bit 3  */
    #define LCD_RS_PORT      LCD_PORT     /**< port for RS line         */
    #define LCD_RS_PIN       1            /**< pin  for RS line         */
    #define LCD_RW_PORT      LCD_PORT     /**< port for RW line         */
    #define LCD_RW_PIN       2            /**< pin  for RW line         */
    #define LCD_E_PORT       LCD_PORT     /**< port for Enable line     */
    #define LCD_E_PIN        3            /**< pin  for Enable line     */
    
    #elif defined(__AVR_AT90S4414__) || defined(__AVR_AT90S8515__) || defined(__AVR_ATmega64__) || \
          defined(__AVR_ATmega8515__)|| defined(__AVR_ATmega103__) || defined(__AVR_ATmega128__) || \
          defined(__AVR_ATmega161__) || defined(__AVR_ATmega162__)
    /*
     *  memory mapped mode is only supported when the device has an external data memory interface
     */
    #define LCD_IO_DATA      0xC000    /* A15=E=1, A14=RS=1                 */
    #define LCD_IO_FUNCTION  0x8000    /* A15=E=1, A14=RS=0                 */
    #define LCD_IO_READ      0x0100    /* A8 =R/W=1 (R/W: 1=Read, 0=Write   */
    #else
    #error "external data memory interface not available for this device, use 4-bit IO port mode"
    
    #endif
    
    
    /**
     *  @name Definitions for LCD command instructions
     *  The constants define the various LCD controller instructions which can be passed to the 
     *  function lcd_command(), see HD44780 data sheet for a complete description.
     */
    
    /* instruction register bit positions, see HD44780U data sheet */
    #define LCD_CLR               0      /* DB0: clear display                  */
    #define LCD_HOME              1      /* DB1: return to home position        */
    #define LCD_ENTRY_MODE        2      /* DB2: set entry mode                 */
    #define LCD_ENTRY_INC         1      /*   DB1: 1=increment, 0=decrement     */
    #define LCD_ENTRY_SHIFT       0      /*   DB2: 1=display shift on           */
    #define LCD_ON                3      /* DB3: turn lcd/cursor on             */
    #define LCD_ON_DISPLAY        2      /*   DB2: turn display on              */
    #define LCD_ON_CURSOR         1      /*   DB1: turn cursor on               */
    #define LCD_ON_BLINK          0      /*     DB0: blinking cursor ?          */
    #define LCD_MOVE              4      /* DB4: move cursor/display            */
    #define LCD_MOVE_DISP         3      /*   DB3: move display (0-> cursor) ?  */
    #define LCD_MOVE_RIGHT        2      /*   DB2: move right (0-> left) ?      */
    #define LCD_FUNCTION          5      /* DB5: function set                   */
    #define LCD_FUNCTION_8BIT     4      /*   DB4: set 8BIT mode (0->4BIT mode) */
    #define LCD_FUNCTION_2LINES   3      /*   DB3: two lines (0->one line)      */
    #define LCD_FUNCTION_10DOTS   2      /*   DB2: 5x10 font (0->5x7 font)      */
    #define LCD_CGRAM             6      /* DB6: set CG RAM address             */
    #define LCD_DDRAM             7      /* DB7: set DD RAM address             */
    #define LCD_BUSY              7      /* DB7: LCD is busy                    */
    
    /* set entry mode: display shift on/off, dec/inc cursor move direction */
    #define LCD_ENTRY_DEC            0x04   /* display shift off, dec cursor move dir */
    #define LCD_ENTRY_DEC_SHIFT      0x05   /* display shift on,  dec cursor move dir */
    #define LCD_ENTRY_INC_           0x06   /* display shift off, inc cursor move dir */
    #define LCD_ENTRY_INC_SHIFT      0x07   /* display shift on,  inc cursor move dir */
    
    /* display on/off, cursor on/off, blinking char at cursor position */
    #define LCD_DISP_OFF             0x08   /* display off                            */
    #define LCD_DISP_ON              0x0C   /* display on, cursor off                 */
    #define LCD_DISP_ON_BLINK        0x0D   /* display on, cursor off, blink char     */
    #define LCD_DISP_ON_CURSOR       0x0E   /* display on, cursor on                  */
    #define LCD_DISP_ON_CURSOR_BLINK 0x0F   /* display on, cursor on, blink char      */
    
    /* move cursor/shift display */
    #define LCD_MOVE_CURSOR_LEFT     0x10   /* move cursor left  (decrement)          */
    #define LCD_MOVE_CURSOR_RIGHT    0x14   /* move cursor right (increment)          */
    #define LCD_MOVE_DISP_LEFT       0x18   /* shift display left                     */
    #define LCD_MOVE_DISP_RIGHT      0x1C   /* shift display right                    */
    
    /* function set: set interface data length and number of display lines */
    #define LCD_FUNCTION_4BIT_1LINE  0x20   /* 4-bit interface, single line, 5x7 dots */
    #define LCD_FUNCTION_4BIT_2LINES 0x28   /* 4-bit interface, dual line,   5x7 dots */
    #define LCD_FUNCTION_8BIT_1LINE  0x30   /* 8-bit interface, single line, 5x7 dots */
    #define LCD_FUNCTION_8BIT_2LINES 0x38   /* 8-bit interface, dual line,   5x7 dots */
    
    
    #define LCD_MODE_DEFAULT     ((1<<LCD_ENTRY_MODE) | (1<<LCD_ENTRY_INC) )
    
    
    
    /** 
     *  @name Functions
     */
    
    
    /**
     @brief    Initialize display and select type of cursor
     @param    dispAttr \b LCD_DISP_OFF display off\n
                        \b LCD_DISP_ON display on, cursor off\n
                        \b LCD_DISP_ON_CURSOR display on, cursor on\n
                        \b LCD_DISP_ON_CURSOR_BLINK display on, cursor on flashing             
     @return  none
    */
    extern void lcd_init(uint8_t dispAttr);
    
    
    /**
     @brief    Clear display and set cursor to home position
     @param    void                                        
     @return   none
    */
    extern void lcd_clrscr(void);
    
    
    /**
     @brief    Set cursor to home position
     @param    void                                        
     @return   none
    */
    extern void lcd_home(void);
    
    
    /**
     @brief    Set cursor to specified position
     
     @param    x horizontal position\n (0: left most position)
     @param    y vertical position\n   (0: first line)
     @return   none
    */
    extern void lcd_gotoxy(uint8_t x, uint8_t y);
    
    
    /**
     @brief    Display character at current cursor position
     @param    c character to be displayed                                       
     @return   none
    */
    extern void lcd_putc(char c);
    
    
    /**
     @brief    Display string without auto linefeed
     @param    s string to be displayed                                        
     @return   none
    */
    extern void lcd_puts(const char *s);
    
    
    /**
     @brief    Display string from program memory without auto linefeed
     @param    s string from program memory be be displayed                                        
     @return   none
     @see      lcd_puts_P
    */
    extern void lcd_puts_p(const char *progmem_s);
    
    
    /**
     @brief    Send LCD controller instruction command
     @param    cmd instruction to send to LCD controller, see HD44780 data sheet
     @return   none
    */
    extern void lcd_command(uint8_t cmd);
    
    
    /**
     @brief    Send data byte to LCD controller 
     
     Similar to lcd_putc(), but without interpreting LF
     @param    data byte to send to LCD controller, see HD44780 data sheet
     @return   none
    */
    extern void lcd_data(uint8_t data);
    
    
    /**
     @brief macros for automatically storing string constant in program memory
    */
    #define lcd_puts_P(__s)         lcd_puts_p(PSTR(__s))
    
    /*@}*/
    #endif //LCD_H
    
  • #6 8441771
    gaskoin
    Poziom 38  
    pokaż jeszcze kod maina :)
  • #7 8441783
    Rafał_
    Poziom 10  
    oto main :)

    #include "lcd.c"
    #include <avr/io.h>

    int main(void)
    {
    DDRD=0xFF;
    lcd_init(LCD_DISP_ON);
    lcd_puts("xxx");
    while(1);
    }
  • #9 8441813
    Rafał_
    Poziom 10  
    dzięki wielkie ;) ... ech ... :D
REKLAMA