atmega328 funktioniert teilweise nicht

[Lowtzow .. (lowtzow)]

hallo leute

hatte schon vor einigen wochen ein ähnliches problem und aufeinmal ging 
wieder alles aber nun da es wieder auftritt weiß ich nicht mehr weiter.

ich habe in einer bestehenden schaltung einen mega8 im einsatz, wo alles 
funktioniert. da das programm nun größer wird bin ich auf den mega328 
umgestiegen der auch zeitweise funktioniert. alle register habe ich 
angepasst und fuse auf extern quarz geschalten.

steuere mit der schaltung ein lcd an, das mit dem mega328 plötzlich nach 
einiger zeit balken anzeigt als würde es nicht richtig angesteuert.
ok beim ersten mal nahm ich einen 2. mega328 mit funktionierendem 
programm und deto - balken. nach einigen hin und her funktioniert 
plötzlich das lcd mit beiden mega328.

heute das selbe problem.
habe alle pins durchgemessen, verbunden ist alles.
nehm ich den mega8 funktioniert alles problemlos.
jedoch mitn mega328, kann ich reseten und neu programmen soviel ich 
will, nix funkt.
kann mir das verhalten nicht erklären wieso sich der mega328 aufhängt, 
habe brownout disable/2,7V
timing vom quarz leicht verändert

aja system läuft mit 3,3v und 16mhz
ich gönn dem mega328 wieder ne pause vielleicht funkt er morgen?!

hat wer nen tipp?
ich kann mir nicht vorstellen, dass am programm liegt...

[AVRuser (Gast)]

Hallo,

> system läuft mit 3,3v und 16mhz

Ich denke, es sind 16 Megahertz und keine Millihertz ...

Hast du die Datenblätter studiert? Dann müsstest du feststellen, dass 
bei beiden Controllern 16MHz Takt nur bei einer Versorgungsspannung von 
4.5V bis 5.5V erlaubt sind. D.h., du betreibst die Controller mit den 
3.3V ausserhalb der von ATMEL vorgegebenen Spezifikationen.
Das kann funktionieren, muss aber nicht; es wird von ATMEL nicht 
garantiert.

Also muss entweder der Takt runter (nur beim Mega328; der Mega8 ist gar 
nicht für 3.3V vorgesehen, nur der Mega8V) oder die Versorgungsspannung 
auf 5V rauf.

Erst danach macht es Sinn, weiter nach Fehlern zu suchen ...

[Lowtzow .. (lowtzow)]

ok kann ich versuchen

MHz natürlich ;-)
irgendwo im datenblatt habe ich gefunden, so eine grafik die bei 2,7v 
bei 10Mhz war und bei 5V bei 20Mhz, so steil ansteigend. zumindestens 
bei der hat es so ausgesehen, dass bei 3,3v sich 16Mhz ausgehen sollten.
jedenfalls werde ich mal auf die internen osi umschalten da kann ich den 
externen quarz dran hängen lassen und es sollt funktionieren. berichte 
am nachmittag wieder ;-)

der mega8 läuft problemlos, habe mal in einem thread gelesen, dass die 
mega8 selektiert sind. d.h. die besseren werden zu 2,7-5,5v &16Mhz 
modellen die anderen zu 5V modellen mit 8mhz. jedenfalls läuft mein 
mega8-16pu stabil.

mfg

[Justus S. (jussa)]

Lowtzow .... schrieb:
> zumindestens
> bei der hat es so ausgesehen,

nur mit Knick in der Optik...außerdem ist den mega328-Grafiken die 
3,3V-Kurve immer nur bis 12,6 MHz. Und auch wenn man nur von der 
Übersichtskurve ausgeht, was hat dich denn daran gehindert, mal eben aus 
zu rechnen, wie hoch die Maxfrequenz bei 3,3V ist?

[Lowtzow .. (lowtzow)]

tja, wie gesagt, ein bestehendes system, hab die kurve dann auch nur mal 
zufällig gesehen...

hab jetzt vorher schon mal nachgerechnet und bei 3,3v gehts max bis 
13Mhz.
habe die frequenz auf interne 8Mhz gestellt und habe leider das selbe 
problem, wenn ich das selbe Programm (register natürlich angepasst) auf 
einen Mega8 mit internen 8Mhz betreiber funktioniert alles problemlos



ich häng mal sicherheitshalber den code für den mega328 an

/*****************************************************************
Titel:     Messung des Puls mittels eines Polar Brustgurt

Author:    Alex & Michael

Software:   AVR-GCC 4.14

Hardware:   TL074
      LM567
      HD44780 compatible text LCD

*******************************************************************/


#include <stdlib.h>
#include <avr/io.h>
#include "lcd.h"
#include "HRM11-mega328.h"                      // Author:    Peter Fleury
#include <avr/signal.h>
#include <inttypes.h>


ISR(TIMER1_COMPA_vect){                    //Interrupt routine, variable wird jede ms erhöht
  run_ms1++;

  
}

ISR(INT0_vect){                        //Ext.Interrupt auf PIN0

  static volatile uint16_t int0_falling_time = 0;      //wird für Int0 benötigt
  static volatile uint16_t int0_rising_time = 0;      //wird für Int0 benötigt
  

  if ( !( EICRA & (1<< ISC00  )) ) {            // ICS00=0 => Interrupt bei fallender Flanke

    int0_falling_time = run_ms1;            //Auslösezeit wird gespeichert

    EICRA |= ( 1 << ISC00 ) | ( 1 << ISC01 );       //ICS00 & ICS01 = 1 => INT0 reagiert auf steigende Flanke

  }
    
    else{                          //ICS00&ICS01 =1 Interrupt bei steigender Flanke

      int0_rising_time = run_ms1;              //Auslösezeit wird gespeichert

      EICRA &= ~(1 << ISC00);                //ICS00 = 0 => INT0 reagiert auf fallende Flanke

    }

  if( ( int0_rising_time - int0_falling_time ) >= signal_time_low &&
    ( int0_rising_time - int0_falling_time ) <= signal_time_high) {    // wenn signallänge 3-7ms

    //impuls_3_start_time[run_impuls_3] = run_ms1;            //bei 3-7ms impuls startzeit ins array schreiben
    impuls_3_start_time[run_impuls_3] = int0_rising_time;            //bei 3-7ms impuls startzeit ins array schreiben

    run_impuls_3++;                          //array_laufvariable erhöhen
//**************************************************************************************
    test2=run_impuls_3;
//**************************************************************************************
    if (run_impuls_3>=array_lenght_impuls_3) {                    //array_laufvariable = 0
      run_impuls_3 = 0;
    }
  }

}    

/********************************************************************************************
In dieser Funktion wird der Code für die Polar-Funkstrecke gesucht
solange kein Code gefunden wurd d.h. code = 0 wird dieses Programm durchlaufen
wenn ein Code gefunden wurde, wird dieser der variable code zugewiesen
********************************************************************************************/
void code_search(void){        //code für übertragung wird gesucht

  if (code==0){          //solange kein code gefunden, wird routine durchlaufen
  
    static uint8_t search = 0;  //varriable für codesuche
  
    for (uint8_t i= 0; i < array_lenght_impuls_3 ; i++){ //Array wird durchsucht 
  
      search+=5;        //suchvarriable wird jeweils um 5 erhöht
    
      if(search>=255)      //falls suchvariable überläuft
        search=0;        

      if(  impuls_3_start_time[i+1] - impuls_3_start_time[i] == search &&
        impuls_3_start_time[i+2] - impuls_3_start_time[i] == search+20){


        code=search;    //wenn code gefunden, wird dieser hier übergeben
        
      }
    }
  }    
}
    
/********************************************************************************************      
Hier wird das Array nach gültigen Signalen durchsucht also unsren 3 spikes, 
wurden die 3 spikes gefunden so wird die startzeit in ein array geschriben, 
womit weiter gerechnet werden kann  
*********************************************************************************************/
void impuls_decode(void){

  if (code!=0){                //erst wenn code gefunden wurde, wird diese routine durchlaufen

    static uint8_t j;                                            //laufvariable für signal start time

    for (uint8_t i = 0; i < array_lenght_impuls_3 ; i++){               //60 werte array wird durchlaufen  
  
      if(  impuls_3_start_time[i+1] - impuls_3_start_time[i] <= code+5 &&
        impuls_3_start_time[i+1] - impuls_3_start_time[i] >= code-5 ){
          
          impuls_1_start_time[j] = impuls_3_start_time[i];              // gültige signale in impuls_start_time array schreiben
          
        //test5=j;
        j++;

        test3=j;
    
        if(j>array_lenght_impuls_1){
          j=0;
        }      
      }      
    }
  }
}




void puls_berechnung(void){    
  
if(run_sek>=run_sek3)  {     // >= für LCD aktualisierung ca 100ms

  run_sek3=run_sek + 1;
  if(run_sek3>=62){
    run_sek3=0;

//    test7=run_sek3;
  }
    
      static uint8_t k = 0;    
      if(code != 0) {
        for(uint8_t j = 0; j < array_lenght_impuls_1 ; j++){       //60 werte
      
          if (impuls_1_start_time[j+1]-impuls_1_start_time[j] >= 300 &&       
            impuls_1_start_time[j+1]-impuls_1_start_time[j] <= 1200)  {    //ob puls zwischen 60-200schläge pro minute 1sek-0,3sek
                      
            heartbeat_now = 60000 / ( (float) impuls_1_start_time[j+1]-(float)impuls_1_start_time[j] ); //aus der laufzeit wird der puls berechnet
            
            heartbeat[k]=heartbeat_now;  //gültigen puls in heartbeat array schreiben
              
            
              
            /*****************************************************************
            min und max werte im bezug auf den durchschnittpuls herausfiltern

            puls>>durchschnitt  =>  puls = durchschnitt
            puls<<durchschnitt  =>  puls = durchschnitt
            *****************************************************************/
            uint32_t avarange=0;  //hilfsvariable für duchschnitt

            for (uint8_t m=0;m<=array_lenght_heartbeat_start-1;m++){    
              avarange += heartbeat[k];  //alle werte aufsumieren
            }
            avarange/=array_lenght_heartbeat_start;  //durchschnitt berechnen        

            for (uint8_t m=0;m<=array_lenght_heartbeat_start-1;m++){  
                
              if(avarange+20>heartbeat[m]) //puls>>durchschnitt  =>  puls = durchschnitt
                heartbeat[m]=avarange;

              if(avarange-20<heartbeat[m]) //puls<<durchschnitt  =>  puls = durchschnitt
                heartbeat[m]=avarange;                  
            }

            k++;
////////////////////////////////////////////////
            test5=k;
////////////////////////////////////////////////

            if(k>=array_lenght_heartbeat_start)
              k=0;
            
          }
        }
      }

    

  }

}

            
              

  
    





int main(void){


  PORTD |= (1<<PORTD2);              //PUll-up PD2 einschalten
  DDRD &= ~(1 << DDD2);            //PD2 => Eingang


  //************* Timer1 config für 1ms
  TIMSK1 |= (1<<OCIE1A);          //Timer1 Output Compare A MAtch Interrupt Enable
  OCR1A = 1000;              // von 0 bis zu disem Wert wird gezählt 16Mhz/(2*8*(1/1ms))
  TCCR1B |= (1<<CS11) | (1<<WGM12);    //F_CPU/8 & CTC Mode
  sei();                  //Globale Interrupt enable
  //***********************************

  //*************Ext.Interrupt0 config Signalerkennung
  EIMSK|=(1<<INT0);            //Ext. Interrupt aktivieren PD2
  EICRA|=(1<<ISC00);             //Any logical change on INT0 generates an interrupt request.
  //************************************

  lcd_init(LCD_DISP_ON);          //Display initialisieren
  
    
  
  for(;;){
    lcd_gotoxy(0,0);          //zu anfangskoordinaten des lcd springen

    impuls_decode();

    puls_berechnung();    
                // wenn noch kein code vorhanden -> codesuche
    code_search();



    run_sek=run_ms1/1000;  //millisikunden in sekunden umrechnen und varaible zuordnen
      if (run_sek >= 62){  //wenn sekunden 62 ->0
      run_sek=0;      
      run_sek2=0;      
        }
      if (run_ms1 >=62050)
        run_ms1=0;

    
    

    if(run_sek>=run_sek2)  {     // >= für LCD aktualisierung ca 100ms
      run_sek2++;        // um 100ms erhöht

      
      /****************************************************
      gleitender mittelwert aktualisierungsadauer 8sek

      output = input/8 + output - output/8
      ****************************************************/
      heartbeat_input=heartbeat_now;
      heartbeat_output=heartbeat_input/8+heartbeat_output-(heartbeat_output/8); //averaging data stream
      

      lcd_clrscr();          //lcd wird gelöscht

      char text[177];          //wird für die übergabe für sprintf benötigt
      //ZEILE 1//
      lcd_gotoxy(0,0);
      sprintf(text,"code:%d sek%u",code, run_sek);;   //ausgabe adc0 und akt.intervall via sprintf
      //sprintf(text,"%u %u %u %u %u",heartbeat[0],heartbeat[1],heartbeat[2],heartbeat[3],heartbeat[4]);
      lcd_puts(text);          //text aus sprintf wird auf dem lcd ausgegeben
      

      lcd_gotoxy(0,1);
      //ZEILE 3//
      //sprintf(text,"3im%u 1im%u bpm%u",test2, test3,test5);; //ausgabe adc0 und akt.intervall via sprintf
      sprintf(text,"%u %u %u %u %u",impuls_3_start_time[5],impuls_3_start_time[6],impuls_3_start_time[7],impuls_3_start_time[8],impuls_3_start_time[9]);
      lcd_puts(text);  

      lcd_gotoxy(0,2);
      //ZEILE 3//
      sprintf(text,"average bpm %u ",(int)heartbeat_now);; //ausgabe adc0 und akt.intervall via sprintf
      lcd_puts(text);  


      lcd_gotoxy(0,3);
      //ZEILE 3//
      sprintf(text,"in%u out%u",(int)heartbeat_input,(int)heartbeat_output); //ausgabe adc0 und akt.intervall via sprintf
      lcd_puts(text);  


    

    }
  }
}

das h. file

#define signal_time_low 3                //min. länge des Signals
#define signal_time_high 18                //max. länge des Signals

#define signal_delay_low 10                //max. ldelay des Signals ca 20ms
#define signal_delay_high 25
#define array_lenght_impuls_3 60          //Array größe
#define array_lenght_impuls_1 25          //Array größe
#define array_lenght_heartbeat_start 20          //Array größe


static volatile uint16_t run_ms1 = 0;            //wird jede ms um 1 erhöht 0-65535ms => ca.65sek


uint16_t impuls_3_start_time[array_lenght_impuls_3];  //hier wird die startzeit der impulse geschrieben
uint16_t impuls_1_start_time[array_lenght_impuls_1];  //hier wird die startzeit der signale geschrieben
static volatile uint8_t run_impuls_3 = 0;      //Array Laufvariable
static volatile uint8_t run_impuls_1 = 0;      //Array Laufvariable

uint8_t heartbeat[array_lenght_heartbeat_start]={0};   //array für 10 Werte
uint8_t heartbeat_ave[array_lenght_heartbeat_start];


uint32_t mittelwert_alt=0;
uint32_t mittelwert_neu=0;
uint32_t heartbeat_output=90;
uint32_t heartbeat_input=0;
uint8_t heartbeat_now=0;


uint8_t test2 =0;
uint8_t test3=0;
//uint8_t test4=0;
uint8_t test5=0;



uint8_t run_sek=0;
uint8_t run_sek2=0;
uint8_t run_sek3=0;



uint8_t code = 0;

extern void ISR(TIMER1_COMPA_vect);
extern void ISR(INT0_vect);
extern void code_search(void);
extern void impuls_decode(void);
extern void puls_berechnung(void);
extern int main(void);

und die lcd.h

 #ifndef LCD_H
#define LCD_H
/*************************************************************************
 Title  :   C include file for the HD44780U LCD library (lcd.c)
 Author:    Peter Fleury <[e-mail]>  http://jump.to/fleury
 File:      $Id: lcd.h,v 1.13.2.2 2006/01/30 19:51:33 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 [e-mail] http://jump.to/fleury

      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  Definition for LCD controller type
 * Use 0 for HD44780 controller, change to 1 for displays with KS0073 controller.
 */
#define LCD_CONTROLLER_KS0073 0  /**< Use 0 for HD44780 controller, 1 for KS0073 controller */

/** 
 *  @name  Definitions for Display Size 
 *  Change these definitions to adapt setting to your display
 */
#define LCD_LINES           4     /**< 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  0x10     /**< DDRAM address of first char of line 3 */
#define LCD_START_LINE4  0x50     /**< 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         PORTC       /**< port for the LCD lines   */
#define LCD_DATA0_PORT   PORTD     /**< port for 4bit data bit 0 */
#define LCD_DATA1_PORT   PORTD     /**< port for 4bit data bit 1 */
#define LCD_DATA2_PORT   PORTB     /**< port for 4bit data bit 2 */
#define LCD_DATA3_PORT   PORTB     /**< port for 4bit data bit 3 */
#define LCD_DATA0_PIN    6            /**< pin for 4bit data bit 0  */
#define LCD_DATA1_PIN    7            /**< pin for 4bit data bit 1  */
#define LCD_DATA2_PIN    0            /**< pin for 4bit data bit 2  */
#define LCD_DATA3_PIN    1            /**< pin for 4bit data bit 3  */
#define LCD_RS_PORT      PORTD     /**< port for RS line         */
#define LCD_RS_PIN       3            /**< pin  for RS line         */
#define LCD_RW_PORT      PORTD     /**< port for RW line         */
#define LCD_RW_PIN       4            /**< pin  for RW line         */
#define LCD_E_PORT       PORTD     /**< port for Enable line     */
#define LCD_E_PIN        5            /**< 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

[Pete K. (pete77)]

In der lcd.h ist XTAL auf 8Mhz gesetzt. Stimmt das mit FCPU überein?
Werden die delay.h Routinen benutzt?
Poste mal Deine Schaltung.
Das LCD funktioniert mit 3,3V?

[Lowtzow .. (lowtzow)]

Pete K. schrieb:
> In der lcd.h ist XTAL auf 8Mhz gesetzt. Stimmt das mit FCPU überein?
> Werden die delay.h Routinen benutzt?
> Poste mal Deine Schaltung.
> Das LCD funktioniert mit 3,3V?

hallo

fcpu = 8mhz
die delay.h wird nicht benutzt, läuft alles über timer oder "system 
time"
das lcd, läuft mit 5V für kontrast, ansprechen tue ich es jedoch direkt 
mit den megaxxx mit 3,3V

hab den datentraffic an den lcd pins mitn oszi gemessen, beim mega8 
werden daten hinübergeschaufelt, beim mega328 ist stille

[Lowtzow .. (lowtzow)]

ich glaube ich weiß wo der fehler liegt.

und zwar habe ich einen parallel programmer, und mit meiner avrdude vers 
kann ich keinen mega328 programmieren.
habe avrisp zum programmieren gefunden, funkt auch ganz gut.
jedenfalls habe ich noch aus alten zeiten bascom, was ich auch teilweise 
für die fuse zum setzten verwende (da kenn mich auch), jedenfalls wenn 
ich mit bascom das hex file zum mega328 sende dann bekomme ich in 
derzeit in 95% der fälle einen fehler nach dem vertify, wo er sagt das 
ein wert nicht stimmt (avr isp hat nur programmiert und kein vertify 
gemacht).
und jedesmal wenn ich diesen fehler bekomme hängt der avr, wenn kein 
fehler kommt dann läuft das programm.

hab mir letztens eh einen avr mkII bestellt, mit dem kann man vom 
avrstudio aus gleich programmieren, hoffe es klappt dann besser.
jedenfalls danke! und ich berichte sobald ich den neuen programmer habe.