undefined reference to 'main'

[Elektrotiger (Gast)]

sitze seit ner halben Stunde und suche den verdammten Fehler -.-

/************************************************************************/
/*                                                                      */
/*                      Debouncing 8 Keys                               */
/*                      Sampling 4 Times                                */
/*                      With Repeat Function                            */
/*                                                                      */
/*              Author: Peter Dannegger                                 */
/*                      [e-mail]                                  */
/*                                                                      */
/************************************************************************/
 
#include <avr/io.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "main.h"
#include "lcd.h"
#include <avr/wdt.h>
#include <avr/interrupt.h>
#include <util/delay.h>
#include <inttypes.h>
 
#ifndef F_CPU
#define F_CPU           7372800                   // processor clock frequency
#warning kein F_CPU definiert
#endif 
 
#define KEY_DDR         DDRC
#define KEY_PORT        PORTC
#define KEY_PIN         PINC
#define KEY_mitte       7
#define KEY_links       3
#define KEY_rechts      4
#define KEY_oben    6
#define KEY_unten    2
#define ALL_KEYS        (1<<KEY_mitte | 1<<KEY_links | 1<<KEY_rechts | 1<<KEY_oben | 1<<KEY_unten)
 
#define REPEAT_MASK     (1<<KEY_links | 1<<KEY_rechts | 1<<KEY_mitte | 1<<KEY_oben | 1<<KEY_unten)       // repeat: key1, key2
#define REPEAT_START    50                        // after 500ms
#define REPEAT_NEXT     20                        // every 200ms
 
#define LED_DDR         DDRD
#define LED_PORT        PORTD
#define LED0            0
#define LED1            1
#define LED2            2
#define LED3      3
#define LED4            4
#define LED5      5
 
#define ADCINPUTS 8    // Anzahl der ADC Eingänge
 
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
uint16_t display_update = 100;          // Aktualisierungstimer Display in ms
volatile uint8_t menu =0;
volatile uint16_t countdown =0;
 
/*
    Globale Variablen im RAM
*/
char ram_string[32];
uint8_t counter=0 , ledcounter=0;
volatile uint8_t flag_update_display = 0;  // Variable jederzeit änderbar
volatile uint8_t flag_start=1;
volatile uint8_t flag_countdown=0;
volatile uint8_t flag_firstcount=0;
uint16_t sekunden=0;
uint16_t adc[ADCINPUTS];
uint8_t flag_high[ADCINPUTS];


void timer0()
{
  TCCR0 = (1<<CS02)|(1<<CS00);         // divide by 1024
  TCNT0 = (-72);  // preload for 10ms
  TIMSK |= 1<<TOIE0;                   // enable timer interrupt
}
 
ISR( TIMER0_OVF_vect )                            // every 10ms
{
  static uint8_t ct0, ct1, rpt;
  uint8_t i;
 
  TCNT0 = (-72);  // 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
 
   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;
  }
  
  counter++;
  if(!(flag_start))    // Kein Startzustand mehr
  {
    if((countdown==0) && (flag_firstcount!=0))
    {
      flag_countdown = 0;
    }
    else countdown--;
    if(flag_countdown==0)
    {
      menu = 1;
      PORTB &= ~(1<<PB0);
      lcd_clear();
      lcd_setcursor(0,0);
      lcd_string("Standardmodus");
      flag_countdown=1;      
    }
  }
  if(menu==2)
  {
    if(counter==(display_update)/10)
      {
        flag_update_display = 1;
      }
  }
  if(menu==1)
  {
    if(counter==(display_update)/10)
    {
      flag_update_display = 1;
    }
  if(counter==100)  // 1 Sekunde
  {
    sekunden++;
    switch(ledcounter)
    {
      case 0: PORTD ^= (1<<PD0); break;
      case 1: PORTD ^= (1<<PD1); break;
      case 2: PORTD ^= (1<<PD2); break;
      case 3: PORTD ^= (1<<PD3); break;
      case 4: PORTD ^= (1<<PD4); break;
      case 5: PORTD ^= (1<<PD5); break;
      case 6: PORTD ^= (1<<PB6); break;
      case 7: PORTD ^= (1<<PB7); break;
    }
    ledcounter++;
    if(ledcounter==8)ledcounter=0;
    counter=0;
  }    
}
 
///////////////////////////////////////////////////////////////////
//
// check if a key has been pressed. Each pressed key is reported
// only once
//
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;
}
 
///////////////////////////////////////////////////////////////////
//
// 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.
//
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;
}
 
///////////////////////////////////////////////////////////////////
//
// 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 );
}
 
///////////////////////////////////////////////////////////////////
//
uint8_t get_key_long( uint8_t key_mask )
{
  return get_key_press( get_key_rpt( key_mask ));
}
 
 
void ADC_Init(void) 
{
  cli(); 
  PORTB &= ~(1 << PB0);  // Blaue LED resetten
  ACSR = (1<<ACD);  // Analog Comperator AUS
  
  // die Versorgungsspannung AVcc als Refernz wählen:
  ADMUX = (1<<REFS0);   
   
/*  oder interne Referenzspannung als Referenz für den ADC wählen:
  ADMUX = (1<<REFS1) | (1<<REFS0);
 
  Bit ADFR ("free running") in ADCSRA steht beim Einschalten
  schon auf 0, also single conversion
  

  ADC Takt zwischen 50-200kHz
  TFmin = CLK/200kHz = 36,8 (7,372MHz)
  Nächstgrößerer Teilungsfaktor: 64
  mit ADPS2 = 1 , ADPS1 = 1 und ADPS0 = 0 */

  ADCSRA = ((1<<ADPS2)|(1<<ADPS1));
  ADCSRA &= ~(1<<ADPS0);  
  ADCSRA = (1<<ADEN); // ADC aktivieren              
 
/*  nach Aktivieren des ADC wird ein "Dummy-Readout" empfohlen, man liest
    also einen Wert und verwirft diesen, um den ADC "warmlaufen zu lassen" */
 
  ADCSRA |= (1<<ADSC);                  // eine ADC-Wandlung 
  while (ADCSRA & (1<<ADSC) )           // auf Abschluss der Konvertierung warten
  {      
  }  
/*  ADCW muss einmal gelesen werden, sonst wird Ergebnis der nächsten
    Wandlung nicht übernommen. */

  sei();
  (void) ADCW;
}


uint16_t ADC_Read( uint8_t channel )
{
  // Kanal waehlen, ohne andere Bits zu beeinflußen
  ADMUX = (ADMUX & ~(0x1F)) | (channel & 0x1F);
  ADCSRA |= (1<<ADSC);            // eine Wandlung "single conversion"
  while (ADCSRA & (1<<ADSC) )     // auf Abschluss der Konvertierung warten
  {  
  }
  return ADCW;                    // ADC auslesen und zurückgeben
}

/* ADC Mehrfachmessung mit Mittelwertbbildung */
/* beachte: Wertebereich der Summenvariablen */
uint16_t ADC_Read_Avg( uint8_t channel, uint8_t nsamples )
{
  uint32_t sum = 0;
 
  for (uint8_t i = 0; i < nsamples; ++i ) 
  {
    sum += ADC_Read( channel );
  }
 
  return (uint16_t)( sum / nsamples );
}



void declaration()
{
/*  WDTCR = (1<<WDTOE);
  WDTCR &= ~(1<<WDE);  // Watchdog deaktivieren */
  DDRB = 0xFF; // Blaue LED: Ausgang
  PORTB &= ~(1<< PB0); 
  DDRC = 0x00; // Eingänge
  DDRC = ((1 << DDC0) | (1 << DDC1)) ; // PC0-3 Ausgang
  PORTC = 0xFF;
  PORTC &= ~((1<<PC0) | (1 <<PC1)); 
  
  DDRD = 0xFF;  // Alle Pins von Port D als Ausgang
  PORTD = (0<<PD0)| (0<<PD1)|(0<<PD2)|(0<<PD3)|(0<<PD4)|(0<<PD5)|(0<<PD6); 
  
  DDRA = 0xFF; // LCD Ausgänge
  DDRA &= ~((1<<PA6) | (1<<PA7));  // ADC Eingänge  
} 
 
 
int main( void )
{
  double dAufloesung = 5000/(2*2*2*2*2*2*2*2*2*2);  
    char cEingang;
    int8_t i=6, k=0;
    
  LED_PORT = 0xFF;
  LED_DDR = 0xFF;                     
 
  // Configure debouncing routines
  KEY_DDR &= ~ALL_KEYS;                // configure key port for input
  KEY_PORT |= ALL_KEYS;                // and turn on pull up resistors

  
  /*  IOs initialisieren */

  declaration();
    lcd_init();
  ADC_Init();  
  timer0();  // 10ms
  sei();
  
  // Strings aus dem RAM ausgeben
    // sinnvoll, wenn Variablen in die Formatierung eingebaut werden sollen.
    lcd_clear();
    lcd_setcursor(0,0); // (Spalte,Zeile)
  lcd_string("System Bereit?");
  lcd_setcursor(0,1);
  //lcd_string("78 aktiv!");
  
  for(uint8_t m=6; m<ADCINPUTS; m++)
  {
    adc[m] = ADC_Read_Avg(m,5);
  }
  for (uint8_t l=6; l<ADCINPUTS; l++)
  {
    if(adc[l]>255)flag_high[l]=1;
    else flag_high[l]=0;
  }
  uint8_t x =0;
  if(flag_high[6]==1)
  {
    lcd_string("7");
    x++;
    lcd_setcursor(x,1);
  }
  if(flag_high[7]==1)
  {
    lcd_string("8");  
    x++;
    lcd_setcursor(x,1);
  }
  lcd_string(" aktiv!");
    
  for(uint8_t n=0; n<(ADCINPUTS-2); n++)
  {
    flag_high[n]=0;
  }
  /*while(menu==0)
  {
    
    if(get_key_short(ALL_KEYS))
    {
      menu=1;
    }
  }  
  lcd_clear();
  lcd_setcursor(0,0);
    lcd_string("ADC Werte Test!");    // verbraucht unnötig RAM beim AVR
  lcd_setcursor(0,1);*/
  
  
 
  while(1)
  {
    //if( get_key_short( 1<<KEY_mitte ))
  
      //LED_PORT ^= 1<<LED1;
  /*  
   for(uint8_t m=0; m<ADCINPUTS; m++)
    {
      adc[m] = ADC_Read_Avg(m,5);
    }  */   
    if((PINC & 0b00100000)&& (menu!=4))
    {
       menu=4;
      lcd_clear();
      lcd_setcursor(0,0);
      lcd_string("Poti Test");
    }
    switch(menu)
    {
      case 0: // Start
          {
            if(get_key_short(ALL_KEYS))
            {
  
              lcd_clear();
              lcd_setcursor(0,0);
              lcd_string("Standardmodus!");    // verbraucht unnötig RAM beim AVR
              lcd_setcursor(0,1);  
              menu=1;
              flag_start=0;          
            }                 
          }  break;
        
      case 1:  // Standardbetrieb
          {
            for(uint8_t m=0; m<ADCINPUTS; m++)
            {
              adc[m] = ADC_Read_Avg(m,5);
            }
            for(uint8_t j=6;j<8;j++)
            {
              if((adc[j]<256) && flag_high[j])
              {
                lcd_setcursor(k,1);
                if(j==6)lcd_string("A");
                else if(j==7) lcd_string("B");
                k++;
                if(k==16)k=0;
              }
              else if(adc[j]>255)flag_high[j]=1;            
            }
            if(get_key_short(ALL_KEYS))
            {
              lcd_clear();
              lcd_setcursor(0,0);
              lcd_string("Testmodus");
              countdown = 1000; // 5 Sekunden
              flag_firstcount=1;
              menu = 2;
              LED_PORT = 0x00;
              PORTB |= (1<<PB0);
            }
          }  break;
      case 2:  // Testmodus, ADC läuft weiter, 5 Sekunden ohne Eingabe
          {
            for(uint8_t m=0; m<ADCINPUTS; m++)
            {
              adc[m] = ADC_Read_Avg(m,5);
            }
            if(flag_update_display)
            {
              flag_update_display =0;
              cEingang = '0'+i+1;           // ASCII Codes erzeugen
              lcd_setcursor(0,1);
              sprintf_P(ram_string, PSTR("In %c: %i"), cEingang, (int)(adc[i]*dAufloesung));
              lcd_string(ram_string);             // hier sinnvoll
            }          
            if( get_key_short( 1<<KEY_unten))
            {
              LED_PORT ^= 1<<LED0;
              countdown = 1000; // 5 Sekunden
            }
            if( get_key_long( 1<<KEY_unten))
            {
              LED_PORT ^= 1<<LED1;
              countdown = 1000;
            }
            if( get_key_short( 1<<KEY_oben))
            {
              LED_PORT ^= 1<<LED1;
              countdown = 500; // 5 Sekunden
            }
            if( get_key_short( 1<<KEY_links))
            {
              LED_PORT ^= 1<<LED2;
              countdown = 1000; // 5 Sekunden
            }
            if( get_key_short( 1<<KEY_rechts))
            {  
              LED_PORT ^= 1<<LED0;
              countdown = 1000; // 5 Sekunden
            }
            if (get_key_long(1<<KEY_rechts))
            {
              LED_PORT ^= 1<<LED1;
              countdown = 1000; // 5 Sekunden
            }
            if( get_key_short( 1<<KEY_mitte))
            {
              i++;
              if(i==8)i=6;
              countdown = 1000; // 5 Sekunden
              flag_update_display=1;
            }
                    
            // single press and repeat          
            if( get_key_press( 1<<KEY_oben ) || get_key_rpt( 1<<KEY_oben ))
            {
              countdown = 1000; // 5 Sekunden
              uint8_t i = LED_PORT;            
              i = (i & 0x07) | ((i << 1) & 0xF0);
              if( i < 0xF0 )
              i |= 0x08;
              LED_PORT = i;
            }
          }  break;
      case 4:
          {
            for(uint8_t m=0; m<ADCINPUTS; m++)
            {
              adc[m] = ADC_Read_Avg(m,5);
            }
            if(adc[i]<128)LED_PORT=0b00000010;
            else if((adc[i]>127)&&(adc[i]<256)) LED_PORT=0b00000011;
            else if((adc[i]>255)&&(adc[i]<385))LED_PORT=0b00000111;
            else if((adc[i]>384)&&(adc[i]<512))LED_PORT=0b00001111;
            else if((adc[i]>511)&&(adc[i]<683))LED_PORT=0b00011111;
            else if((adc[i]>682)&&(adc[i]<853))LED_PORT=0b00111111;
            else if(adc[i]>852)LED_PORT=0b01111111;
            if(!(PINC && 0b00100000))flag_countdown=0;
          }  break;
      }
  }
}

[foo (Gast)]

Elektrotiger schrieb:
> sitze seit ner halben Stunde und suche den verdammten Fehler -.-

Wahnsinn, schon so lange?
Aber die Zeit um eine genaue Fehlerbeschreibung zu geben hattest Du 
nicht?

[Peter II (Gast)]

Elektrotiger schrieb:
> sitze seit ner halben Stunde und suche den verdammten Fehler -.-

dann prüfen die Klammern. Am ende sind zu viele }, die fehlt viel weiter 
oben.

[Peter II (Gast)]

Nachtrag:

Zeile: 118+x

>   if(menu==1)
>   {


hier fehlt die schließenden Klammer

[Peter II (Gast)]

Nachtrag2:

> Author: Peter Dannegger

viel dürfte davon nicht von Peter sein.

[Elektrotiger (Gast)]

Peter II schrieb:
> Zeile: 118+x
>
>>   if(menu==1)
>>   {
>
> hier fehlt die schließenden Klammer

Danke !!!! ...

Peter II schrieb:
> viel dürfte davon nicht von Peter sein.

Stimmt schon, nur das Entprellen. Das Projekt ist noch lange nicht 
fertig :D.

[Daniel A. (daniel-a)]

Dashier lässt sich vereinfachen:
5000/(2*2*2*2*2*2*2*2*2*2)
zu
5000/(1<<10)

[Karl H. (kbuchegg)]

Daniel A. schrieb:
> Dashier lässt sich vereinfachen:
> 5000/(2*2*2*2*2*2*2*2*2*2)
> zu
> 5000/(1<<10)

Ist aber genauso unsinnig wie das Original

Wenn schon, dann waere an dieser Stelle ein

  double dAufloesung = 5000.0 / 1024.0;

angebracht.
Aber in dem Programm gaebe es noch so vieles, was ueberarbeitungswuerdig 
waere.

[Yalu X. (yalu) (Moderator)]

Ich frage mich nur, wie ein Syntaxfehler (fehlende Klammer) zu einer
Linker-Meldung (undefined reference to 'main') führen kann.

[Peter II (Gast)]

Yalu X. schrieb:
> Ich frage mich nur, wie ein Syntaxfehler (fehlende Klammer) zu einer
> Linker-Meldung (undefined reference to 'main') führen kann.

die Klammeranzahl stimme ja - irgendwie.

Nur da alles Funktion innerhalb der anderen Funktion lagen und damit hat 
sie der linker nicht gefunden

void foo() 
{
   int main() 
   {
   }
}

[Karl H. (kbuchegg)]

Peter II schrieb:
> Yalu X. schrieb:
>> Ich frage mich nur, wie ein Syntaxfehler (fehlende Klammer) zu einer
>> Linker-Meldung (undefined reference to 'main') führen kann.
>
> die Klammeranzahl stimme ja - irgendwie.

Wobei ich sagen muss, dass ich visuell die überzählige } in main noch 
nicht gefunden habe. Aber irgendwo muss sie sein.

Ganz abgesehen davon wär mir das main mit diesem Monster switch-case 
sowieso viel zu lang und viel zu unübersichtlich. Da sowieso fast alles 
globale Variablen sind spricht nichts dagegen, die einzelnen Code-Stücke 
aus den jeweiligen casees in jeweils eine eigene Funktion zu packen. 
Würde der Code-Qualität gut tun und auch so läppische Fehler in der 
Klammerhierarchie vermeiden helfen.

[Yalu X. (yalu) (Moderator)]

Peter II schrieb:
> die Klammeranzahl stimme ja - irgendwie.

Sicher? Grep zählt 53 öffnende und nur 52 schließende Klammern, wenn man
die auskommentierten Codeabschnitte weglässt.

Und GCC meint:

test.c:515:1: error: expected declaration or statement at end of input
 }
 ^

Ein Object-File wird deswegen gar nicht erst erstellt, weswegen es auch
nichts zu linken gibt.

Ok, wenn man am Ende noch eine schließende Klammer anhängt, ist es so
wie du geschrieben hast.

Mit den Optionen -std=c11 und -pedantic hätte dann immerhin schon der
Compiler einen guten Hinweis auf den eigentlichen Fehler gegeben:

warning: ISO C forbids nested functions

[Karl H. (kbuchegg)]

Yalu X. schrieb:
> Peter II schrieb:
>> die Klammeranzahl stimme ja - irgendwie.
>
> Sicher? Grep zählt 53 öffnende und nur 52 schließende Klammern, wenn man
> die auskommentierten Codeabschnitte weglässt.

Hihi.
D.h. es war ihm selbst schon bewusst, dass da was mit der Klammerung 
nicht stimmt und er (wahrscheinlich ganz zum Schluss) mehr schliessende 
Klammern stehen hat, als da eigentlich sein sollten.
Sauber.

(Und nein. Das Märchen mit dem Copy&Paste Fehler glaub ich mittlerweile 
nicht mehr)

[Tom (Gast)]

Automatische Codeformatierung ist ebenso wichtig wie Compilerwarnungen 
auf Rechtsanschlag. Damit sieht man nämlich sofort, dass in
ISR(TIMER0_OVF_vect)  die schließende Klammer fehlt. Wer mit AVR-Studio 
4, notepad.exe oder ähnlichen Editoren arbeitet, hat natürlich Pech und 
muss selbst Klammern zählen.

[Peter II (Gast)]

Yalu X. schrieb:
> Sicher? Grep zählt 53 öffnende und nur 52 schließende Klammern, wenn man
> die auskommentierten Codeabschnitte weglässt.

naja, mein Editor hat es beim zuklappen der Abschnitte angezeigt. Hatte 
es nicht durch den Compiler gejagt.

[Mark B. (markbrandis)]

#include "main.h"

Was um alles in der Welt mag da wohl deklariert sein?

Es ist nicht üblich, dass die main-Funktion eine eigene Header Datei 
hat. Und wenn was anderes damit gemeint ist, dann ist der Name saublöd 
gewählt ;-)

[Rufus Τ. F. (rufus)]

Mark Brandis schrieb:
> Es ist nicht üblich, dass die main-Funktion eine eigene Header Datei
> hat.

Sofern sie Funktionen bzw. Datenobjekte zur Verfügung stellt, die von 
anderen Modulen (Sourcedateien) aus genutzt werden, ist es das.

[Amateur (Gast)]

1. Zähl mal die geschweiften Klammern in ISR.
2. Pack doch Deinen gesamten Code in die Unterbrechung.

[Mark B. (markbrandis)]

Rufus Τ. Firefly schrieb:
> Mark Brandis schrieb:
>> Es ist nicht üblich, dass die main-Funktion eine eigene Header Datei
>> hat.
>
> Sofern sie Funktionen bzw. Datenobjekte zur Verfügung stellt, die von
> anderen Modulen (Sourcedateien) aus genutzt werden, ist es das.

Ist mir persönlich noch nicht untergekommen, was zugegeben nicht heißt 
dass dies niemals vorkommen kann. Gibt es ein Beispiel für reale 
Software, wo das so gemacht wird?