Wechsel von ATmega8 auf ATmega32 - Codeanpassung

[Tobi (Gast)]

Hallo zusammen,

da mein Programm nach einer Erweiterung für einen ATmega8 zu groß 
geworden ist, versuche ich gerade auf einen ATmega32 umzusteigen.
Ohne die Erweiterung lief das Programm einwandfrei auf dem ATmega8, 
selbiges läuft nach Anpassung aber nicht auf dem 32er.
Genauer gesagt funktionieren die Button nicht. Diese entprelle ich mit 
dem Code von Peter Fleury.
Angeschlossen sind sie nun an Port C (Pin 0-3) des 32ers. JTAG sollte 
eigentlich ausgeschaltet sein über Fuse Bit.
Habe es auch schon an PortB versucht um sicher zu gehen.

Ein angeschlossenes LCD funktioniert so wie es soll, und hat mir bei dem 
ATmega8 immer angezeigt ob ein Button gedrückt wurde (vereinfacht).

Nun bleibt für mich als Fehlerursache ein eventuell falsch 
initialisierter Timer0, der für das "Debouncen" genutzt wird. Kann mir 
jemand sagen, ob ich bei der Anpassung einen Fehler gemacht habe?

Funktionierende Timer-Initialisierung bei ATmega8:

void init_8Bit_Timer0(void){

  TCCR0B = (1<<CS02)|(1<<CS00);         // divide by 1024
  TCNT0 = (uint8_t)(int16_t)-(F_CPU / 1024 * 10e-3 + 0.5);  // preload for 10ms
  TIMSK0 |= 1<<TOIE0;                   // enable timer interrupt
 
    sei();

}

Timer-Initialisierung bei ATmega32:

void init_8Bit_Timer0(void){

  TCCR0 = (1<<CS02)|(1<<CS00);         // divide by 1024
  TCNT0 = (uint8_t)(int16_t)-(F_CPU / 1024 * 10e-3 + 0.5);  // preload for 10ms
  TIMSK |= 1<<TOIE0;                   // enable timer interrupt
 
    sei();

}

Hat vielleicht jemand noch Ideen, an welcher Stelle der Fehler sonst 
lauern könnte?

Ich hoffe die Informationen genügen. Für erste Hilfestellungen wäre ich 
dankbar.

PS.: Mir fällt noch ein, das ich nun mit 8MHz arbeite und nicht wie 
vorher mit 1MHz. Dies habe ich aber als F_CPU eingestellt und auch beim 
Flashen. Sonst würde das LCD ja nicht funktionieren.

Gruß
Tobi

[Detlef K. (adenin)]

Gibt es beim ATmega8 ein TCCR0B Register?
Ich kenne nur TCCR0.
Und TIMSK0 ???

Was sagt den der Simulator zu deinem Code?

[Tobi (Gast)]

Hallo,

ich bitte um Entschuldigung, ich hätte die Typen genauer angeben sollen.
Bei dem ATmega8 handelt es sich um einen ATmega48-20PU.
Bei dem ATmega32 um einen ATmega32-16PU.
Die Register heißen bei diesem Typ wohl etwas anders ;)

Detlef Kunz schrieb:
> Und TIMSK0 ???

Dort setze ich nur das "overflow interrupt enable" Flag.

[Matthias S. (Firma: matzetronics) (mschoeldgen)]

Tobi schrieb:
> Bei dem ATmega8 handelt es sich um einen ATmega48-20PU.
Das ist ein ganz schöner Unterschied.

Öh, wenn nur das Programm zu gross wurde, warum nimmst du dann nicht den 
Mega88/168/328?
Bei denen ist nämlich bis auf RAM und Flashgrösse alles genauso wie beim 
Mega48.

Detlef Kunz schrieb:
> Ich kenne nur TCCR0.

Und auch nur dieses gibt es beim Mega32, nix TCCR0B.

[Detlef K. (adenin)]

Ok, damit ist die Sache mit den Registernamen geklärt.
Jetzt must Du nur noch klären ob im alten Code PinChange-Interrupts 
benutzt wurden, bzw die Flags zu diesen Interrupts.
Hier fehlt (wie üblich) sehr viel an Information zum Programm und der 
verwendeten Hardware.

[Tobi (Gast)]

Matthias Sch. schrieb:
> Öh, wenn nur das Programm zu gross wurde, warum nimmst du dann nicht den
> Mega88/168/328?

Weil ich den ATmega32 noch hier herumfliegen habe ;)

Was sind denn "PinChange-Interrupts", und was fehlt an Infos? Fehlt euch 
die Abfrage der Interrupts von Peter Fleury?

ISR( TIMER0_OVF_vect )                            // every 10ms
{
  static uint8_t ct0, ct1, rpt;
  uint8_t i;
 
  TCNT0 = (uint8_t)(int16_t)-(F_CPU / 1024 * 10e-3 + 0.5);  // preload for 10ms
 
  i = key_state ^ ~KEY_PIN;                       // key changed ?
  ct0 = ~( ct0 & i );                             // reset or count ct0
  ct1 = ct0 ^ (ct1 & i);                          // reset or count ct1
  i &= ct0 & ct1;                                 // count until roll over ?
  key_state ^= i;                                 // then toggle debounced state
  key_press |= key_state & i;                     // 0->1: key press detect
#ifdef KEY_REPEAT_ON
  if( (key_state & REPEAT_MASK) == 0 )            // check repeat function
     rpt = REPEAT_START;                          // start delay
  if( --rpt == 0 ){
    rpt = REPEAT_NEXT;                            // repeat delay
    key_rpt |= key_state & REPEAT_MASK;
  }
#endif
}

Zur Schaltung kann ich nur noch sagen, das die Buttons wie vorher auch 
nach Masse geschaltet sind.
Ich kann auch das gesamte Programm hochladen, wenn das jemand möchte. 
Allerdings wird dann sicherlich mehr über meinen Programmierstil 
debattiert, als über potentielle Fehlerursachen ;)

Aber es muss ja mit den angepassten Stellen zusammenhängen und nicht mit 
dem restlichen Code. Bis auf die Einstellung des richtigen Device, die 
Ports und die 2 Timer (der zweite ist für eine Uhr und läuft), war 
nichts zu ändern.

Gruß
Tobi

[Detlef K. (adenin)]

Im Moment wird nur über den Informationsstil debattiert :P

Und

  ct1 = ct0 ^ (ct1 & i);                          // reset or count ct1

sollte besser

  ct1 = (ct0 ^ ct1) & i;                          // reset or count ct1

lauten

[Tobi (Gast)]

Hat keiner mehr eine Idee woran es liegen könnte?

[Detlef K. (adenin)]

Dann musst Du wohl doch den Code mal hochladen. :(

[Matthias S. (Firma: matzetronics) (mschoeldgen)]

Detlef Kunz schrieb:
> Und

ct1 = ct0 ^ (ct1 & i);                          // reset or count ct1

> sollte besser

ct1 = (ct0 ^ ct1) & i;                          //  reset or count ct1

> lauten

In PeDas Entprellroutine steht aber die erste Variante - und die 
funktioniert tadellos.
http://www.mikrocontroller.net/articles/Entprellung

[Detlef K. (adenin)]

Matthias Sch. schrieb:
> In PeDas Entprellroutine steht aber die erste Variante - und die
> funktioniert tadellos.
> http://www.mikrocontroller.net/articles/Entprellung

Und ich hab es mit dem Code von Peter Fleury verglichen, der im ersten 
Post als Quelle angegeben wurde.

Ein echtes Problem ist aber, das hier (wieder mal) nur Teile eines 
Programmes gepostet werden, und der Fehler irgendwo anders erzeugt 
werden könnte.
Es wäre ja sonst auch zu einfach den Code im Simulator zu testen.

[Kaj (Gast)]

Tobi schrieb:
> Was sind denn "PinChange-Interrupts",
Wenn du ins Datenblatt auf die Pinbelegung schaust, findest du Pins an 
denen PCINTxx steht, (xx durch nummer ersetzen, z.B. 23), das sind die 
Pins fuer Pin-ChangeInterrupt.
Ein Pin-ChangeInterrupt wird ausgeloest, wie der Name ja schon sagt, 
wenn sich das Level an dem entsprechenden Pin aendert. Der Interrupt 
wird dabei aber durch jegliche aenderung am Pin ausgeloest, du hast 
keine Moeglichkeit einzustellen ob der Interrupt nur bei steigender oder 
fallender Flanke ausgeloest werden soll.

Gruesse

[Tobi (Gast)]

Hallo,

zunächst wünsche ich erst mal allen frohe Weihnachten!

Wie bereits geschrieben, kann ich den Code gerne hochladen... Hier ist 
er:

/*************************************************************************
Title:    Aquarium Control v2
Author:   Tobias xxxxxx
Software: AVR-GCC 3.3, HD44780U LCD library by Peter Fleury
Hardware: ATmega32, HD44780 compatible LCD text display
          
**************************************************************************/
#define F_CPU 8000000 //8000000

#include <stdlib.h>
#include <avr/io.h>
#include <avr/pgmspace.h>
#include <util/delay.h>
#include <avr/interrupt.h>    //Interruptheader
#include "lcd.h"

#define INTRO_ON
#define KEY_PRESSED_ON
//#define KEY_REPEAT_ON

/*Defines für Button-Debouncing*/
#define KEY_DDR         DDRC
#define KEY_PORT        PORTC
#define KEY_PIN         PINC
#define KEY0            0
#define KEY1            1
#define KEY2            2
#define KEY3            3
#define ALL_KEYS        (1<<KEY0 | 1<<KEY1 | 1<<KEY2 | 1<<KEY3)
 
#define REPEAT_MASK     (1<<KEY1 | 1<<KEY2)       // repeat: key1, key2
#define REPEAT_START    50                        // after 500ms
#define REPEAT_NEXT     20                        // every 200ms

/*Defines für Transistor-Schalter*/
#define LED_DDR         DDRA
#define LED_PORT        PORTA
#define LED_PIN         PINA
#define LED_BACKLIGHT   1
#define VALVE      0

/*Alternative*/

//#define XTAL    11059201L  // nominal value F_CPU
//#define F_CPU    11059008L  // after measuring deviation: 1.5s/d

#define DEBOUNCE  256L    // debounce clock (256Hz = 4msec)

#define uchar unsigned char
#define uint unsigned int

uchar prescaler;
uchar volatile second;      // count seconds
uchar volatile minute;      // count minute
uchar volatile hour;      // count hour
uchar volatile btnCount = 0;      
uchar volatile countFLAG;
uchar volatile valveFLAG;

typedef enum {  INTRO, 
        INIT_TIMER,
        GRUNDZUSTAND, 
        UHR_AKTUALISIEREN, 
        COUNTER_AKTUALISIEREN, 
        UHR_MENU, 
        VENTIL_MENU,
        VENTIL_MENU1,
        LICHT_MENU,
        LICHT_MENU1, 
        FUTTER_MENU,
        FUTTER_MENU1,
        UHR_STELLEN1,
        UHR_STELLEN2,
        UHR_STELLEN3,
        UHR_STELLEN4,
        VENTIL_AUF_ZU1,
        VENTIL_AUF_ZU2, 
        VENTIL_AUF_UHR1, 
        VENTIL_AUF_UHR2, 
        VENTIL_ZU_UHR1,
        VENTIL_ZU_UHR2, 
        LICHT_STRG, 
        FUTTER_STRG
       } state_t ;
 
state_t volatile state;

volatile uint8_t key_state;                       // debounced and inverted key state:
                                                  // bit = 1: key pressed
volatile uint8_t key_press;                       // key press detect
 
volatile uint8_t key_rpt;                         // key long press and repeat

/*
** constant definitions
*/

static const PROGMEM unsigned char sonderzeichen[64] =
{
  0x00, 0x04, 0x0E, 0x15, 0x04, 0x04, 0x04, 0x00, //Pfeil nach oben
  0x00, 0x04, 0x04, 0x04, 0x15, 0x0E, 0x04, 0x00, //Pfeil nach unten
  0x0A, 0x00, 0x11, 0x11, 0x11, 0x13, 0x0D, 0x00, //Umlaut ü
  0x00, 0x00, 0x07, 0x0A, 0x10, 0x09, 0x07, 0x01, //Fisch Teil 1
  0x00, 0x00, 0x11, 0x0D, 0x03, 0x15, 0x18, 0x00, //Fisch Teil 2
  0x00, 0x0A, 0x0A, 0x00, 0x11, 0x0E, 0x00, 0x00,  //Smiley
  0x00, 0x00, 0x04, 0x0E, 0x1F, 0x0A, 0x0E, 0x00,  //Home
  0x00, 0x10, 0x10, 0x14, 0x12, 0x1F, 0x02, 0x04  //Enter

};
#ifdef INTRO_ON
static const PROGMEM unsigned char bigFish[] =
{
  0x00,0x00,0x00,0x03,0x04,0x08,0x10,0x10,
  0x00,0x07,0x1F,0x00,0x00,0x08,0x18,0x00,
  0x00,0x1C,0x18,0x0C,0x03,0x00,0x00,0x00,
  0x00,0x00,0x03,0x05,0x09,0x12,0x02,0x04,
  
  0x10,0x08,0x06,0x01,0x00,0x00,0x00,0x00,
  0x00,0x00,0x08,0x1C,0x06,0x01,0x00,0x00,
  0x00,0x11,0x12,0x1C,0x10,0x10,0x00,0x00,
  0x04,0x14,0x0C,0x06,0x00,0x00,0x00,0x00 
};
static const PROGMEM unsigned char bigFish_reverse[] =
{
  0x00,0x00,0x18,0x14,0x12,0x09,0x08,0x04,
  0x00,0x07,0x03,0x06,0x18,0x00,0x00,0x00,
  0x00,0x1C,0x1F,0x00,0x00,0x02,0x03,0x00,
  0x00,0x00,0x00,0x18,0x04,0x02,0x01,0x01,

  0x04,0x05,0x06,0x0C,0x00,0x00,0x00,0x00,
  0x00,0x11,0x09,0x07,0x01,0x01,0x00,0x00,
  0x00,0x00,0x02,0x07,0x0C,0x10,0x00,0x00,
  0x01,0x02,0x0C,0x10,0x00,0x00,0x00,0x00
};
#endif

/*
** function prototypes
*/ 

ISR( TIMER0_OVF_vect )                            // every 10ms
{
  static uint8_t ct0, ct1, rpt;
  uint8_t i;
 
  TCNT0 = (uint8_t)(int16_t)-(F_CPU / 1024 * 10e-3 + 0.5);  // preload for 10ms
 
  i = key_state ^ ~KEY_PIN;                       // key changed ?
  ct0 = ~( ct0 & i );                             // reset or count ct0
  ct1 = ct0 ^ (ct1 & i);                          // reset or count ct1
  i &= ct0 & ct1;                                 // count until roll over ?
  key_state ^= i;                                 // then toggle debounced state
  key_press |= key_state & i;                     // 0->1: key press detect
#ifdef KEY_REPEAT_ON
  if( (key_state & REPEAT_MASK) == 0 )            // check repeat function
     rpt = REPEAT_START;                          // start delay
  if( --rpt == 0 ){
    rpt = REPEAT_NEXT;                            // repeat delay
    key_rpt |= key_state & REPEAT_MASK;
  }
#endif
}

ISR(TIMER1_COMPA_vect)             //Bei Compare-Match mit OCR1A (31250) wird Sekunden um eins erhöht.
{
  #if F_CPU % DEBOUNCE
    OCR1A = F_CPU / DEBOUNCE - 1;    // compare DEBOUNCE - 1 times
  #endif
    if( --prescaler == 0 ){
      prescaler = (uchar)DEBOUNCE;
      second++;        // exact one second over
  #if F_CPU % DEBOUNCE      // handle remainder
      OCR1A = F_CPU / DEBOUNCE + F_CPU % DEBOUNCE - 1; // compare once per second
  #endif
  }

  countFLAG = 1;
  valveFLAG = 1;
  
  //Berechnen

    if(second == 60){
      minute++;
      second = 0;
    }

    if(minute == 60){
      hour++;
      minute = 0;
    }

    if(hour == 25){
      hour = 0;
      state = GRUNDZUSTAND;
    }
}

///////////////////////////////////////////////////////////////////
//
// check if a key has been pressed. Each pressed key is reported
// only once
//
#ifdef KEY_PRESSED_ON
uint8_t get_key_press( uint8_t key_mask )
{
  cli();                                          // read and clear atomic !
  key_mask &= key_press;                          // read key(s)
  key_press ^= key_mask;                          // clear key(s)
  sei();
  return key_mask;
}
#endif
///////////////////////////////////////////////////////////////////
//
// check if a key has been pressed long enough such that the
// key repeat functionality kicks in. After a small setup delay
// the key is reported being pressed in subsequent calls
// to this function. This simulates the user repeatedly
// pressing and releasing the key.
//
#ifdef KEY_REPEAT_ON
uint8_t get_key_rpt( uint8_t key_mask )
{
  cli();                                          // read and clear atomic !
  key_mask &= key_rpt;                            // read key(s)
  key_rpt ^= key_mask;                            // clear key(s)
  sei();
  return key_mask;
}
#endif
///////////////////////////////////////////////////////////////////
//
// check if a key is pressed right now
//
uint8_t get_key_state( uint8_t key_mask )
 
{
  key_mask &= key_state;
  return key_mask;
}
 
///////////////////////////////////////////////////////////////////
//
uint8_t get_key_short( uint8_t key_mask )
{
  cli();                                          // read key state and key press atomic !
  return get_key_press( ~key_state & key_mask );
}
 
///////////////////////////////////////////////////////////////////
//
#ifdef KEY_LONG_PRESSED_ON
uint8_t get_key_long( uint8_t key_mask )
{
  return get_key_press( get_key_rpt( key_mask ));
}
#endif

/*
void Einstellen (void)             //Dient dem Einstellen der Uhr
{
  
}
*/
void init_16Bit_Timer1(void){
  //Registerinitialisierung
  
  TCCR1B = 1<<WGM12^1<<CS10;    // divide by 1
          // clear on compare
    OCR1A = F_CPU / DEBOUNCE - 1;
    TCNT1 = 0;
    second = 0;
    prescaler = (uchar)DEBOUNCE;

    TIMSK = 1<<OCIE1A;

  sei();

}

void init_8Bit_Timer0(void){

  TCCR0 = (1<<CS02)|(1<<CS00);         // divide by 1024
  TCNT0 = (uint8_t)(int16_t)-(F_CPU / 1024 * 10e-3 + 0.5);  // preload for 10ms
  TIMSK |= 1<<TOIE0;                   // enable timer interrupt
 
    sei();

}
#ifdef INTRO_ON 
void intro(void){
  lcd_command(_BV(LCD_CGRAM));  /* set CG RAM start address 0 */
     
  int i = 0;
    
  for(i=0; i<8*8; i++)  {
    lcd_data(pgm_read_byte_near(&bigFish[i]));
    }
  int x = 0;
    for(i=0; i<19; i++){
    lcd_clrscr();
    x = 15-i;
    if(x>=0){
      lcd_gotoxy(x,1);
      lcd_putc(0);
      if(i>0) lcd_putc(1);
      if(i>1) lcd_putc(2);
      if(i>2) lcd_putc(3);
      lcd_gotoxy(x,2);
      lcd_putc(4);
      if(i>0) lcd_putc(5);
      if(i>1) lcd_putc(6);
      if(i>2) lcd_putc(7);
    }else if(x==-1){
      lcd_gotoxy(0,1);
      lcd_putc(1);
      lcd_putc(2);
      lcd_putc(3);
      lcd_gotoxy(0,2);
      lcd_putc(5);
      lcd_putc(6);
      lcd_putc(7);
    }else if(x==-2){
      lcd_gotoxy(0,1);
      lcd_putc(2);
      lcd_putc(3);
      lcd_gotoxy(0,2);
      lcd_putc(6);
      lcd_putc(7);
    }else if(x==-3){
    lcd_gotoxy(0,1);
      lcd_putc(3);
      lcd_gotoxy(0,2);
      lcd_putc(7);
    }
    _delay_ms(180);
  }

  lcd_clrscr();
  lcd_gotoxy(5,1);
  lcd_puts("AquaControl");
  lcd_gotoxy(4,2);
  lcd_puts("by T. xxxxxxx");
  
  lcd_command(_BV(LCD_CGRAM));  /* set CG RAM start address 0 */
  i = 0;
  
  for(i=0; i<8*8; i++)
  {
    lcd_data(pgm_read_byte_near(&bigFish_reverse[i]));
    }
  _delay_ms(500);
  for(i=0; i<=3; i++){
    
    lcd_gotoxy(0,1);
    if(i>2) lcd_putc(0);
    if(i>1) lcd_putc(1);
    if(i>0) lcd_putc(2);
    lcd_putc(3);
    
    lcd_gotoxy(0,2);
    if(i>2) lcd_putc(4);
    if(i>1) lcd_putc(5);
    if(i>0) lcd_putc(6);
    lcd_putc(7);

    _delay_ms(250);
  }
  
  lcd_gotoxy(4,1);
  //lcd_putc(':');//0xDF
  lcd_puts("\xdf");
  
  _delay_ms(250);
  lcd_gotoxy(4,1);
  lcd_putc(' ');
  lcd_gotoxy(4,0);
  lcd_putc('o');
  _delay_ms(250);
  lcd_gotoxy(4,0);
  lcd_putc(' ');
  
  _delay_ms(1000);
  
}
#endif
void menuLeiste(void){
  lcd_gotoxy(0,3);
  lcd_putc(' ');
  lcd_putc(1);
  lcd_puts("   ");
  lcd_putc(0);
  lcd_puts("    ");
  lcd_putc(7);
  lcd_puts("    ");
  lcd_putc(6);
}
int main(void)
{
    state_t state = INTRO;
  char buffer[7];
  short int valve = -1;
  int uhr_stell_position = 0;
  
  countFLAG = 0;
  valveFLAG = 0;
  
  short int uhr_stell_mode = 0;


  uchar Ventil_Time_auf_sec = 0;
  uchar Ventil_Time_auf_min = 0;
  uchar Ventil_Time_auf_hour = 7;

  uchar Ventil_Time_zu_sec = 0;
  uchar Ventil_Time_zu_min = 0;
  uchar Ventil_Time_zu_hour = 18;
  

  int change_second = 0;
  int change_minute = 0;
  int change_hour = 0;
  int i = 0;

  second = 0;
  minute = 0;
  hour = 0;

  btnCount = 0;

  
    // Configure debouncing routines
    KEY_DDR &= ~ALL_KEYS;                // configure key port for input
    KEY_PORT |= ALL_KEYS;                // and turn on pull up resistors

  LED_PORT |= (1<<LED_BACKLIGHT);
  LED_DDR  |= (1 << LED_BACKLIGHT)|(1 << VALVE);
  
  init_8Bit_Timer0();

    /* initialize display, cursor off */
    lcd_init(LCD_DISP_ON);

  for (;;) {                           /* loop forever */

    if(valveFLAG == 1){
      valveFLAG = 0;
      if(hour == Ventil_Time_auf_hour && minute == Ventil_Time_auf_min && second == Ventil_Time_auf_sec){
        LED_PORT &= ~(1 << VALVE);
        valve = -1;
        state = GRUNDZUSTAND;
      }else if(hour == Ventil_Time_zu_hour && minute == Ventil_Time_zu_min && second == Ventil_Time_zu_sec){
        LED_PORT |= (1<<VALVE);
        valve = 1;
        state = GRUNDZUSTAND;
      }
    }
    switch(state){
       case INTRO:
        #ifdef INTRO_ON
        intro();
        #endif
        lcd_command(_BV(LCD_CGRAM));  /* set CG RAM start address 0 */
        i = 0;
        for(i=0; i<64; i++)
        {
          lcd_data(pgm_read_byte_near(&sonderzeichen[i]));
          }
        state = INIT_TIMER;
        break;
      case INIT_TIMER:
        init_16Bit_Timer1();
        state = GRUNDZUSTAND;
        break;
      case GRUNDZUSTAND:
        /* clear display and home cursor */
            lcd_clrscr();
        
            /* put string to display (line 1) with linefeed */
            lcd_puts("Zeit:");
        
        lcd_gotoxy(0,1);
        lcd_puts("Zaehler:");

        lcd_gotoxy(0,2);
        if(valve == 1){
          lcd_puts("CO2-Zufuhr:   an");
        }else{
          lcd_puts("CO2-Zufuhr:  aus");
        }
        lcd_gotoxy(12,3);
        lcd_puts("Men");
        lcd_putc(2);
        state = COUNTER_AKTUALISIEREN;
        break;
      case UHR_AKTUALISIEREN:
        if(countFLAG == 1){
          //Zurücksetzen
          countFLAG = 0;
          //Ausgeben
          lcd_gotoxy(8,0);
          if(hour <= 9){
            lcd_gotoxy(9,0);
          }
          utoa( hour , buffer, 10);
              lcd_puts(buffer);
          lcd_putc(':');
          if(minute <= 9){
            lcd_putc('0');
          }
          utoa( minute , buffer, 10);
              lcd_puts(buffer);
          lcd_putc(':');
          if(second <= 9){
            lcd_putc('0');
          }
          utoa( second , buffer, 10);
              lcd_puts(buffer);
        }
        if(get_key_short( 1<<KEY0 )){
          btnCount++;
          
          if(btnCount > 100){
            btnCount = 0;
            state = GRUNDZUSTAND;
          }else{
            state = COUNTER_AKTUALISIEREN;
          }
          
        }
        if(get_key_short( 1<<KEY3 )){
          state = UHR_MENU;
        }
        break;
      case COUNTER_AKTUALISIEREN:
        lcd_gotoxy(13,1);
        if(btnCount<10){
          lcd_gotoxy(15,1);
        }else if(btnCount<100){
          lcd_gotoxy(14,1);
        }

        if(btnCount != 0){
          utoa( btnCount , buffer, 10);
          lcd_puts(buffer);
        }else{
          lcd_putc('0');
        }
        state = UHR_AKTUALISIEREN;
        break;
      case UHR_MENU:
        lcd_clrscr();
        lcd_home();
        
        lcd_puts("Uhr-Einst.");
        lcd_gotoxy(1,1);
        lcd_puts("Uhr stellen");
        state = UHR_STELLEN1;
        menuLeiste();
        break;
      case VENTIL_MENU:
        lcd_clrscr();
        lcd_home();
        lcd_puts("Ventil-Einst.");
        lcd_gotoxy(1,1);
        lcd_puts("man. Steuerung");
        lcd_gotoxy(1,2);
        lcd_puts("u.Zeitsteuerung");
        menuLeiste();
        state = VENTIL_MENU1;
        break;
      case VENTIL_MENU1:
        if(get_key_short( 1<<KEY0 )){
          state = LICHT_MENU;
        }
        if(get_key_short( 1<<KEY1 )){
          state = UHR_MENU;
        }
        if(get_key_short( 1<<KEY2 )){
          state = VENTIL_AUF_ZU1;
        }
        
        if(get_key_short( 1<<KEY3 )){
          //Home
          state = GRUNDZUSTAND;
        }
        break;
      case LICHT_MENU:
        lcd_clrscr();
        lcd_home();
        lcd_puts("Licht-Einst.");
        lcd_gotoxy(1,1);
        lcd_puts("Keine Einst.");
        lcd_gotoxy(1,2);
        lcd_puts("m\xEFglich");
        menuLeiste();
        lcd_gotoxy(9,3);
        lcd_puts("  ");
        state = LICHT_MENU1;
        break;
      case LICHT_MENU1:
        if(get_key_short( 1<<KEY0 )){
          state = FUTTER_MENU;
        }
        if(get_key_short( 1<<KEY1 )){
          state = VENTIL_MENU;
        }
        if(get_key_short( 1<<KEY3 )){
          //Home
          state = GRUNDZUSTAND;
        }
        break;
      case FUTTER_MENU:
        lcd_clrscr();
        lcd_home();
        lcd_puts("Futter-Einst.");
        lcd_gotoxy(1,1);
        lcd_puts("Keine Einst.");
        lcd_gotoxy(1,2);
        lcd_puts("m\xEFglich");
        menuLeiste();
        lcd_gotoxy(9,3);
        lcd_puts("  ");
        state = FUTTER_MENU1;
        break;
      case FUTTER_MENU1:
        if(get_key_short( 1<<KEY0 )){
          state = UHR_MENU;
        }
        if(get_key_short( 1<<KEY1 )){
          state = LICHT_MENU;
        }
        if(get_key_short( 1<<KEY3 )){
          //Home
          state = GRUNDZUSTAND;
        }
        break;
      case UHR_STELLEN1:
        if(get_key_short( 1<<KEY0 )){
          state = VENTIL_MENU;
        }
        if(get_key_short( 1<<KEY1 )){
          state = FUTTER_MENU;
        }
        if(get_key_short( 1<<KEY2 )){
          //Uhr stellen
          change_second = second;
          change_minute = minute;
          change_hour = hour;
          uhr_stell_position = 0;
          uhr_stell_mode = 0;
          state = UHR_STELLEN2;
        }
        
        if(get_key_short( 1<<KEY3 )){
          //Home
          state = GRUNDZUSTAND;
        }
        break;
      case UHR_STELLEN2:
        lcd_clrscr();
        lcd_home();
        lcd_puts("Uhr stellen");
        
        lcd_gotoxy(uhr_stell_position+1,2);
        lcd_putc('^');

        lcd_gotoxy(0,3);
        lcd_puts(" +   -   ");
        lcd_putc('\x7E');
        lcd_puts("   OK");
        state = UHR_STELLEN3;
        
        break;
      case UHR_STELLEN3:
        lcd_gotoxy(0,1);
        if(change_hour <= 9){
          lcd_gotoxy(1,1);
        }
        
        utoa( change_hour , buffer, 10);
            lcd_puts(buffer);
        
        lcd_putc(':');
        if(change_minute <= 9){
          lcd_putc('0');
        }
        utoa( change_minute , buffer, 10);
            lcd_puts(buffer);
        
        lcd_putc(':');
        
        if(change_second <= 9){
          lcd_putc('0');
        
        }
        utoa( change_second , buffer, 10);
            lcd_puts(buffer);

        state = UHR_STELLEN4;
        break;
      case UHR_STELLEN4:
        state = UHR_STELLEN3;
        //+
        if(get_key_short( 1<<KEY0 )){
          if(uhr_stell_position == 0){
            change_hour++;
            if(change_hour >= 24){
              change_hour = 0;
              state = UHR_STELLEN2;
            }
          }else if(uhr_stell_position == 3){
            change_minute++;
            if(change_minute >= 60){
              change_minute = 0;
            }
          }else if(uhr_stell_position == 6){
            change_second++;
            if(change_second >= 60){
              change_second = 0;
              
            }
          }
          
        }
        //-
        if(get_key_short( 1<<KEY1 )){
          state = UHR_STELLEN3;
          if(uhr_stell_position == 0){
            change_hour--;
            if(change_hour < 0){
              change_hour = 23;
            }if(change_hour == 9){
              state = UHR_STELLEN2;
            }
          }else if(uhr_stell_position == 3){
            change_minute--;
            if(change_minute <0 ){
              change_minute = 59;              
            }
          }else if(uhr_stell_position == 6){
            change_second--;
            if(change_second < 0){
              change_second = 59;              
            }
          }
          
        }
        if(get_key_short( 1<<KEY2 )){
          //Weiter ->
          uhr_stell_position += 3;
          if(uhr_stell_position > 6){
            uhr_stell_position = 0;
          }
          state = UHR_STELLEN2;
        }
        if(get_key_short( 1<<KEY3 )){
          //Okay
          if(uhr_stell_mode == 0){
            second = change_second;
            minute = change_minute;
            hour = change_hour;
          }else if(uhr_stell_mode == 1){
            Ventil_Time_auf_sec = change_second;
            Ventil_Time_auf_min = change_minute;
            Ventil_Time_auf_hour = change_hour;
          }else if(uhr_stell_mode == 2){
            Ventil_Time_zu_sec = change_second;
            Ventil_Time_zu_min = change_minute;
            Ventil_Time_zu_hour = change_hour;
          }
          state = GRUNDZUSTAND;
        }
        break;
      case VENTIL_AUF_ZU1:
        lcd_clrscr();
        lcd_home();
        lcd_puts("Ventil-Status:");
        if(valve == 1){
          lcd_gotoxy(7,1);
          lcd_puts("geschlossen");
        }else{
          lcd_gotoxy(8,1);
          lcd_puts("ge");
          lcd_putc('\xEF');
          lcd_puts("ffnet");
        }
        
        menuLeiste();
        state = VENTIL_AUF_ZU2;
        break;
      case VENTIL_AUF_ZU2:
        if(get_key_short( 1<<KEY0 )){
          state = VENTIL_AUF_UHR1;
        }
        if(get_key_short( 1<<KEY1 )){
          state = VENTIL_ZU_UHR1;
        }
        if(get_key_short( 1<<KEY2 )){
          //Ventil steuern
          valve *= -1;
          LED_PORT ^= (1<<VALVE);
          state = VENTIL_AUF_ZU1;
        }
        if(get_key_short( 1<<KEY3 )){
          //Home
          state = GRUNDZUSTAND;
        }
        break;
      case VENTIL_AUF_UHR1:
        lcd_clrscr();
        lcd_home();
        lcd_puts("Zeitpunkt zum");
        lcd_gotoxy(0,1);
        lcd_putc('\xEF');
        lcd_puts("ffnen festlegen");
        menuLeiste();
        state = VENTIL_AUF_UHR2;
        break;
      case VENTIL_AUF_UHR2:
        if(get_key_short( 1<<KEY0 )){
          state = VENTIL_ZU_UHR1;
        }
        if(get_key_short( 1<<KEY1 )){
          state = VENTIL_AUF_ZU1;
        }
        if(get_key_short( 1<<KEY2 )){
          //VENTIL_AUF_UHR einstellen
          change_second = Ventil_Time_auf_sec  ;
          change_minute = Ventil_Time_auf_min ;
          change_hour = Ventil_Time_auf_hour;
          uhr_stell_position = 0;
          uhr_stell_mode = 1;
          state = UHR_STELLEN2;
        }
        if(get_key_short( 1<<KEY3 )){
          //Home
          state = GRUNDZUSTAND;
        }
        break;
      case VENTIL_ZU_UHR1:
        lcd_clrscr();
        lcd_home();
        lcd_puts("Zeitpunkt zum");
        lcd_gotoxy(0,1);
        lcd_puts("schliessen fest-");
        lcd_gotoxy(0,2);
        lcd_puts("legen");
        menuLeiste();
        state = VENTIL_ZU_UHR2;
        break;
      case VENTIL_ZU_UHR2:
        if(get_key_short( 1<<KEY0 )){
          state = VENTIL_AUF_ZU1;
        }
        if(get_key_short( 1<<KEY1 )){
          state = VENTIL_AUF_UHR1;
        }
        if(get_key_short( 1<<KEY2 )){
          //VENTIL_ZU_UHR einstellen
          change_second = Ventil_Time_zu_sec  ;
          change_minute = Ventil_Time_zu_min ;
          change_hour = Ventil_Time_zu_hour;
          uhr_stell_position = 0;
          uhr_stell_mode = 2;
          state = UHR_STELLEN2;
        }
        if(get_key_short( 1<<KEY3 )){
          //Home
          state = GRUNDZUSTAND;
        }
        break;
      case LICHT_STRG:
        lcd_clrscr();
        lcd_home();
        break;
      case FUTTER_STRG:
        lcd_clrscr();
        lcd_home();
        break;
      default:
        break;
     }     
    }
}

Nicht hochgeladen habe ich lcd.c und lcd.h von Peter Fleury, da diese 
bis auf die Port-Anpassung unverändert sind. Aber das Display 
funktioniert ja wie erwähnt tatellos.
Ich möchte an dieser Stelle noch einmal darauf hinweisen, das dieser 
Code hier auf dem ATmega48 keine Probleme bereitet hat.

Gruß
Tobi

[Michael (Gast)]

Wichtige Regeln - erst lesen, dann posten!

    Groß- und Kleinschreibung verwenden
--> Längeren Sourcecode nicht im Text einfügen, sondern als Dateianhang

[Matthias S. (Firma: matzetronics) (mschoeldgen)]

Tobi schrieb:
> if(hour == 25){
>       hour = 0;
>       state = GRUNDZUSTAND;

Unbedeutend, nur ein kleiner Vertipper. Deine Uhr springt erst bei 25:00 
Uhr auf 0 und nicht bei 24:00.
Ahh, sage mal, hast du denn die JTAGEN Fuse desaktiviert? Die JTAG Pins 
belegen nämlich einen Teil von deinem Keyboard Port und haben schon so 
manchen in die Verzweifelung getrieben - möglicherweise zuletzt deine 
Fische.

[Tobi (Gast)]

Hallo,

das mit 25:00 Uhr ist mir noch gar nicht aufgefallen, vielen Dank ;)
Betreffendes Fuse Bit sollte eigentlich korrekt gelöscht sein, habe mal 
einen Screenshot angehängt.

Gruß
Tobi

[Tobi (Gast)]

Hallo,

ich habe nun noch ein wenig herum probiert. Leider kann ich das ganze 
nicht anständig debuggen, da ich Hapsim nicht zum laufen bekomme. Der 
AVR-Hook funktioniert angeblich (Haken ist da), die Porteinstellungen in 
Hapsim sind auch korrekt eingetragen, aber leider komme ich nicht über 
die LCD Routine hinaus.

Also habe ich versucht Pseudo-Hardware-Debugging zu betreiben ;)

Wenn ich die Variable btnCount mit in die ISR vom Button-Debouncing 
nehme, wird diese bis 142 hochgezählt und ab da nicht weiter. Das 
entspricht grob 142 * 10 ms Laufzeit... Also wird die ISR wenigstens 
ausgelöst.
Daraufhin habe ich diese Stelle wieder gelöscht und direkt nach dem 
Intro den passenden Button gedrückt und siehe da, es erscheint eine "1" 
für die Variable btnCount auf dem Display. Anschließend werden aber 
wieder keine Button angenommen.

D.h. für kurze Zeit funktioniert die Routine. Vielleicht hilft das ja 
hier dem ein oder anderen für eine neue Theorie... um mir zu helfen ;)

Gruß
Tobi

[Tobi (Gast)]

Fehler gefunden! :>

Tobi schrieb:
> TIMSK = 1<<OCIE1A;

Trotzdem danke an die, die es wirklich versucht haben ;)

Gruß
Tobi