Codesequenz mehrmals brauchen = auslagern

[Alain F. (fox82)]

Hallo Zusammen,

gibt es eine Möglichkeit Codesequenzen innerhalb der Hauptschleife 
respektive in while(1) auszulagern?
Ich habe z.B. Codesequenzen, welche mehrmals gebraucht werden in der 
Schleife.

Danke und Gruss Alain


void Programmteil1(void)

while(1);

Programmteil1();

[Peter II (Gast)]

ja

[Chris L. (kingkernel)]

klar, in eine eigene funktion auslagern und daran denken, dass d die 
nötigen parameter übergiebst

[int16_t foo () (Gast)]

Stichwort: Strukturierte Programmierung.

Wenn es sehr, sehr, sehr zeitkritisch ist, geht das auch per include. 
Das ist aber kein guter Stil.

[Alain F. (fox82)]

Da ist das Problem ich habe es schon wie oben ausprobiert. Das geht 
auch, aber wenn ich Variablen etc. habe dann klappt das nicht mehr.

Gibt es da ein Beispiel?

[Peter II (Gast)]

Alain F. schrieb:
> Gibt es da ein Beispiel?
ja in jeden C bucht.

Versuch es doch einfach mal, wenn es fehler gib dann frag uns.

[Tokyo D. (tokyodrift)]

> Wenn es sehr, sehr, sehr zeitkritisch ist, geht das auch per include.
Das macht man dann aber eher per inline als per include.

[Markus W. (Firma: guloshop.de) (m-w)]

Alain F. schrieb:
> Da ist das Problem ich habe es schon wie oben ausprobiert. Das geht
> auch, aber wenn ich Variablen etc. habe dann klappt das nicht mehr.

Geht es dir darum, einfach nur den Programmcode, also den reinen 
Programmtext mehrfach zu verwenden?

Dann mach das mit "#define". Beispiel:

#define IRGENDWAS a= 1; \
                     b= 2;

while(i==0) {
  IRGENDWAS
  i++;
  }
IRGENDWAS
c= 3;

[int16_t foo () (Gast)]

Tokyo Drift schrieb:
> Das macht man dann aber eher per inline

In C wohl eher nicht. ;-)

[Peter II (Gast)]

int16_t foo () schrieb:
> In C wohl eher nicht. ;-)

warum nicht?

[int16_t foo () (Gast)]

Peter II schrieb:
> warum nicht?

inline gehört zu C++

[Tokyo D. (tokyodrift)]

>> The specification for inline is section 6.7.4 of the C99 standard (ISO/IEC 
9899:1999).
http://www.greenend.org.uk/rjk/tech/inline.html

[Peter II (Gast)]

int16_t foo () schrieb:
> inline gehört zu C++

oder auch nicht
http://www.greenend.org.uk/rjk/tech/inline.html

[int16_t foo () (Gast)]

Peter II schrieb:
> oder auch nicht
> http://www.greenend.org.uk/rjk/tech/inline.html

Ok, wieder etwas gelernt. :-)

Aber ist inline nicht nur eine Empfehlung an den Compiler? Oder wird 
garantiert der Code eingefügt?

[Markus E. (engelmarkus)]

Er muss das beim Kompilieren dann nicht berücksichtigen, wenn er nicht 
will.
Aber es geht ja um den Code, nicht darum, was der Compiler daraus macht!

[int16_t foo () (Gast)]

Markus E. schrieb:
> Aber es geht ja um den Code, nicht darum, was der Compiler daraus macht!

Nö, es geht hier darum, den Code an der Stelle einzufügen, also genau 
das was der Compiler daraus macht! Sonst nimmt natürlich Funktionen.

[Walter S. (avatar)]

Alain F. schrieb:
> while(1);
>
> Programmteil1();

zum Programmteil1 kommt das Programm nie,

bei Makros gibt es auch einen beliebten Fehler:

#define IRGENDWAS a= 1; \
                     b= 2;

while(i==0)
  IRGENDWAS

macht nicht das was du eigentlich vor hattest

[Peter II (Gast)]

int16_t foo () schrieb:
> Nö, es geht hier darum, den Code an der Stelle einzufügen, also genau
> das was der Compiler daraus macht!

denke ich nicht, es soll so aussehen ob der code an der stelle ist. Ob 
der Funktionaufruf noch stattfindet wird den Threadersteller ziemlich 
egal sein. Wer solche Fragen stellt, schreibt allegmeint nicht 
hochoptimierten C code wo es auf 4 Takte drauf ankommt.

[int16_t foo () (Gast)]

Peter II schrieb:
> denke ich nicht,

int16_t foo () schrieb:
> Wenn es sehr, sehr, sehr zeitkritisch ist, geht das auch per include.

Ich beziehe mich auf meinen Post und die Variante mit include. Dann 
bekomme ich garantiert den Code an den gewünschten Punkt.

Und:

int16_t foo () schrieb:
> Das ist aber kein guter Stil.

Bitte die letzten Post in diesem Zusammenhang sehen.

[Alain F. (fox82)]

genau der Code sollte genau an dieser Stelle so eingesetzt werden.
void sleep_p(void){
}
und einfügen geht nicht. Copile Error.

#define benutze ich schon z.B. für das #define Enable    (1<<PD5).
ist aber auch das falsche. Denn auch hier werden die Variablen etc. 
nicht berücksichtigt.

Ich möchte einfach den Code 1:1 rauskopieren z.B.

Code 1 {
bla bla bla
}

int main (void) {  
while(1){   
Code 1;
}
}

[Peter II (Gast)]

Alain F. schrieb:
> Ich möchte einfach den Code 1:1 rauskopieren z.B.
> Code 1 {
> bla bla bla
> }
> main{}
> while(1){
> Code 1;
> }
> }

zeig uns bitte ein sinnvolles Beispiel. Dann es muss gehen. Es sollte 
also wenigstens sinnvoller C code sein.

[Markus W. (Firma: guloshop.de) (m-w)]

Alain F. schrieb:
> #define benutze ich schon z.B. für das #define Enable    (1<<PD5).
> ist aber auch das falsche. Denn auch hier werden die Variablen etc.
> nicht berücksichtigt.

Doch, "#define" ist schon richtig.

Ich hab dein Beispiel mal umgebaut:

#define CODE(x) { \
  bla bla \
  variable= x; \
  bla bla \
  }

int main (void) {
  while(1){
    CODE(1)
    }
  }

[Alain F. (fox82)]

#define LED4    (1<<PD0)
#define LED3    (1<<PD1)
#define LED2    (1<<PD7)
#define LED1    (1<<PD4)

int main (void) {   

 while(1){  

if ( (DIM_value == 290) ){
PORTD&=~LED1;
PORTD&=~LED2;
PORTD|=LED3;
PORTD&=~LED4;
_delay_ms(500);
}

}
}

so ich hätte jetzt gerne den ganzen Block if ausgelagert.
z.B.

#define LED4    (1<<PD0)
#define LED3    (1<<PD1)
#define LED2    (1<<PD7)
#define LED1    (1<<PD4)

int main (void) {   

 while(1){  
Code1;
}
}

Code1{
if ( (DIM_value == 290) ){
PORTD&=~LED1;
PORTD&=~LED2;
PORTD|=LED3;
PORTD&=~LED4;
_delay_ms(500);
}
}

[Peter II (Gast)]

#define ist erstmal der falsche weg, schreibe eine normale funktion. 
#defines sind mehr eine notlösung. Versuche es erstmal so es andere auch 
machen - mit funktionen.

[Peter II (Gast)]

#define LED4    (1<<PD0)
#define LED3    (1<<PD1)
#define LED2    (1<<PD7)
#define LED1    (1<<PD4)

void Code1() {
   if ( (DIM_value == 290) ){
      PORTD&=~LED1;
      PORTD&=~LED2;
      PORTD|=LED3;
      PORTD&=~LED4;
      _delay_ms(500);
   }
};


int main (void) {   
   while(1){  
      Code1();
   }
}

so sollte es passen.

[Alain F. (fox82)]

es geht auch nicht um die defines diese finde ich gut, z.B. wenn man den 
Pin ändert etc. dann kann man nur ganz oben im Code den neuen Pin 
zuweisen und gut ist. Ausserdem gibt es eine Übersicht.
Aber das ist hier nicht die Frage, sondern wie bekomme ich irgend einen 
Code raus. das muss doch gehen, das der Compiler diesen Code in einem 
Abschnitt genau so in mein Code einfügt als ob er dort stehen würde.

[Alain F. (fox82)]

@Peter II

make: *** [ATMEGA8.o] Fehler 1
Build failed with 3 errors and 11 warnings...

[Peter II (Gast)]

Alain F. schrieb:
> make: *** [ATMEGA8.o] Fehler 1
>
> Build failed with 3 errors and 11 warnings...

und welche Fehler?

[Alain F. (fox82)]

../ATMEGA8.c:511:1: warning: implicit declaration of function 'Sleep_p'

[Peter II (Gast)]

Alain F. schrieb:
> 'Sleep_p'

kommt doch im code überhaupt nicht vor? welche includes hast du noch?

Zeig doch mal den completten code.

[int16_t foo () (Gast)]

Alain F. schrieb:
> Aber das ist hier nicht die Frage, sondern wie bekomme ich irgend einen
> Code raus. das muss doch gehen, das der Compiler diesen Code in einem
> Abschnitt genau so in mein Code einfügt als ob er dort stehen würde.

Nicht der Compiler, sondern der preprocessor. Das Zauberwort heisst 
include, auch wenn es den anderen Jungs nicht schmeckt.

[Alain F. (fox82)]

Ich kann nicht den ganzen Code posten ist zu lang und zu komplex.

ich habe:

void sleep_p() {
PORTD&=~LED1;
PORTD&=~LED2;
PORTD&=~LED3;
PORTD&=~LED4;

Off2:;

EIMSK |= (1 << INT0);  // Interupt auf INT0 freigeben

Off:; //OFF Marker
On = 0;
PORTD&=~Enable;
ADMUX = 0b00000000;    // Internal Reference Disabled
ADCSRA = ~(1<<ADEN); //ADC Disable = Stromsparen 0.3mA
TCCR1A = ~(1<<COM1A1); // Disable PWM
_delay_ms(150);
set_sleep_mode(SLEEP_MODE_PWR_DOWN);
sleep_mode();
}

vor main so hinzugefügt und

im while hier eingefügt:
if (Sleep_c == 1) {

sleep_p();

}

[BaldAbsolvent (Gast)]

Hi Alain,

ich habe keine Möglichkeit, es auszuprobieren. Allerdings sehe ich einen 
gravierenden Fehler in deinem Code:

Du definierst die Funktion Code1 NACH der main Funktion. In C geht das 
nicht. Also entweder wie Peter die Funktion VOR der main Funktion 
schreiben, oder aber NACH der main Funktion (wie du es gemacht hast) - 
dann aber vorher deklarieren.

void Code1();
...
...
...
deine main funktion

...
...
...
void Code1() {
   if ( (DIM_value == 290) ){
      PORTD&=~LED1;
      PORTD&=~LED2;
      PORTD|=LED3;
      PORTD&=~LED4;
      _delay_ms(500);
   }
};

Gruß

[Peter II (Gast)]

Alain F. schrieb:
> Ich kann nicht den ganzen Code posten ist zu lang und zu komplex.

also das Forum hat keine Begrenzung. Wenn du ihn nicht posten willst uns 
die fehler nicht nennst. Dann kann man dir leider auch kaum helfen.

[BaldAbsolvent (Gast)]

Wobei ich finde, dass die Warnung ziemlich eindeutig klingt:

Alain F. schrieb:
> ../ATMEGA8.c:511:1: warning: implicit declaration of function 'Sleep_p'

http://www.cplusplus.com/doc/tutorial/functions2/
Abschnitt "Declaring functions"


Oder übersehe ich etwas?


Gruß

[BaldAbsolvent (Gast)]

Ja okay,

ich habe einen wesentlichen Beitrag überlesen.

Alain F. schrieb:
> Some code...
> vor main so hinzugefügt undim while hier eingefügt:
> if (Sleep_c == 1) {
>
> sleep_p();
>
> }

Mein Fehler :)

[Peter II (Gast)]

BaldAbsolvent schrieb:
> Wobei ich finde, dass die Warnung ziemlich eindeutig klingt:

das ist aber nur dir Warung, diese könnte man in diesem fall ignorieren, 
es würde auch so gehen.

> Build failed with 3 errors and 11 warnings...

mich stören mehr diese 3 errors

[BaldAbsolvent (Gast)]

Hi,

Wo ist der Unterschied zwischen "Sleep_p" und "sleep_p" bei dir im Code?

Alain F. schrieb:

> void sleep_p() {
> PORTD&=~LED1;
> PORTD&=~LED2;
> PORTD&=~LED3;
> PORTD&=~LED4;
>
> Off2:;
>
> EIMSK |= (1 << INT0);  // Interupt auf INT0 freigeben
>
> Off:; //OFF Marker
> On = 0;
> PORTD&=~Enable;
> ADMUX = 0b00000000;    // Internal Reference Disabled
> ADCSRA = ~(1<<ADEN); //ADC Disable = Stromsparen 0.3mA
> TCCR1A = ~(1<<COM1A1); // Disable PWM
> _delay_ms(150);
> set_sleep_mode(SLEEP_MODE_PWR_DOWN);
> sleep_mode();
> }

Alain F. schrieb:
> ../ATMEGA8.c:511:1: warning: implicit declaration of function 'Sleep_p'

[Alain F. (fox82)]

so habe den Code gekürzt.
Also ich möchte alles was in if (Sleep_c == 1) auslagern.

#include <avr/io.h>
#include <avr/interrupt.h>
#include <inttypes.h>
#include <avr/pgmspace.h>
#include <avr/wdt.h>
#include <avr/sleep.h>
#include <math.h>
#include <avr/eeprom.h>


#define F_CPU 2000000UL     /* Quarz mit 8.0Mhz */
#include <util/delay.h>



#define Enable    (1<<PD5)
#define PWM      (1<<PB1)



#define Taster_INT0  (1<<PD2)
// PinB5 ON = Never off UnderVoltageCutOut OFF
// PinB4 ON = Power on on Voltage


        #define fosc 2000000      //Taktfrequenz in Hz 
        #define UpperLimit   (unsigned int) (fosc*0.0022)  // Anzahl Ticks für 2,2ms
        #define LowerLimit   (unsigned int) (fosc*0.0008)  // Anzahl Ticks für 0,8ms
        #define Middle     (unsigned int) (fosc*0.0015)  // Anzahl Ticks für 1,5ms


//************************************************************************
//------------------------------------------------------------------------
//************************************************************************
//------------------------------------------------------------------------
//                          Hauptprogramm
//------------------------------------------------------------------------
//************************************************************************
//------------------------------------------------------------------------
//************************************************************************

int main (void) {   

 


//------------------------------------------------------------------------
//            PORTX DDRX
//------------------------------------------------------------------------
   DDRB  = 0b00111110;            //0= Eingang; 1 = Ausgang
   PORTB = 0b00111110;            //0= act. Low; 1 =act. High

   DDRC  = 0b00000000;            //0= Eingang; 1 = Ausgang
   PORTC = 0b00000000;            //0= act. Low; 1 =act. High
   
   DDRD  = 0b11110011;            //0= Eingang; 1 = Ausgang
   PORTD = 0b01001100;            //0= act. Low; 1 =act. High   
   

//------------------------------------------------------------------------
//            ADMUX-Register
//------------------------------------------------------------------------

  ADMUX = 0b00000000;        // Für interne Referenzspannung   ADMUX = 0b11000000; 88P = Internal 1.1V Voltage Reference with external capacitor at AREF pin
                          // auch ADMUX = 2; (Kanalnummer) oder ADMUX = 0b00000010;
  ADCSRA = 1<<ADEN | 1<<ADPS2 | 1<<ADPS1 | 1<<ADPS0;    // Initialisierung des ADC über das ADCSRA-Register
//  ADCSRA = 10000111


//------------------------------------------------------------------------
//            PWM Register 
//------------------------------------------------------------------------

TCCR1A = (1<<WGM10)|(1<<COM1A1)|(1<<COM1B1) ; // 8bit PWM-Modus, nicht invertiernde PWM
TCCR1B = (1<<CS11);             // PWM-Signal Takt Clock / 8 = 500Hz  (LM3421 max 50kHz)

//------------------------------------------------------------------------
//            Interrupt
//------------------------------------------------------------------------

    ACSR = 0x80;      // Analogcomparator ausschalten
    MCUCR &= ~00000011;     // levelgesteuerter Interrupt an INT0
    sei();          // Interrupts freigeben

//------------------------------------------------------------------------
//            Watch Dog
//------------------------------------------------------------------------

// wdt_enable(WDTO_500MS);

//------------------------------------------------------------------------
//             Variablen deklarieren
//------------------------------------------------------------------------

int On = 1;
int x1 =0;
int x = 0;
int Modus = 1;
int DIM_value = 100;
int32_t Taster_Time =0;
int Sleep_c = 1;


//************************************************************************
//------------------------------------------------------------------------
//                          Hauptschleife
//------------------------------------------------------------------------
//************************************************************************

//if ( !(PINB & (1<<PINB4)) ){
goto Jump_ON;

//}

 while(1){    

//Sleep_c = 0;


x1 = x1 + 1;

//------------------------------------------------------------------------
//             Watch Dog
//------------------------------------------------------------------------

//  wdt_reset();


//------------------------------------------------------------------------
//             Clock Speed
//------------------------------------------------------------------------
/*
The CLKPCE bit must be written to logic one to enable change of the CLKPS bits. The CLKPCE
bit is only updated when the other bits in CLKPR are simultaneously written to zero. CLKPCE is
cleared by hardware four cycles after it is written or when CLKPS bits are written. Rewriting the
CLKPCE bit within this time-out period does neither extend the time-out period, nor clear the
CLKPCE bit.
*/
CLKPR = 0b10000000; 

CLKPR = 0b00000010; // Clock divided / 4 = 2 Mhz


// ___________OCR1A Register für PWM Signal ___________________


  OCR1A = 1023; //White

//____________________________________________________




// ---------------- Anschalten (Aufstarten) ------------------
if ( !(PIND & Taster_INT0 ) & (On == 0) ) {
Jump_ON:; //Jump_DIM Marker 
sleep_disable();
//wdt_enable(WDTO_500MS);
Sleep_c = 0;

EIMSK &= ~(1 << INT0);
ADMUX = 0b11000000;    // Internal Reference Enabled    

ADCSRA = 1<<ADEN | 1<<ADPS2 | 1<<ADPS1 | 1<<ADPS0;    

On = 1;
PORTD|=Enable;
_delay_ms(150);

}



// ---------------- Ausschalten (Sleepmodus) ------------------
Taster_Time = 0;

while ( !(PIND & Taster_INT0 ) & (On == 1) ) {

Sleep_c = 1;
}


// ---------------- uC geht schlafen ------------------
if (Sleep_c == 1) {
Off2:;
EIMSK |= (1 << INT0);  // Interupt auf INT0 freigeben
Off:; //OFF Marker
On = 0;
PORTD&=~Enable;
ADMUX = 0b00000000;    // Internal Reference Disabled
ADCSRA = ~(1<<ADEN); //ADC Disable = Stromsparen 0.3mA
TCCR1A = ~(1<<COM1A1); // Disable PWM
//wdt_disable(); // Watchdog ausaschalten
_delay_ms(150);
set_sleep_mode(SLEEP_MODE_PWR_DOWN);
sleep_mode();

}


if (Sleep_c == 0) {

}


}
}

ISR(INT0_vect) { // Interupt Rutine kann leer sein muss aber existieren
}

[Peter II (Gast)]

lösche bitte den code und fang noch mal von vorne an.

Da sind mehre Labels in dem Teil den du auslagern möchstest - das geht 
dann aber nicht. Man darf nicht in ein Funktion reinspringen.

Bitte verwende überhaupt keine gotos, es gibt gründe dafür aber hier 
bestimmt nicht.

[Alain F. (fox82)]

Lieber Peter II, ich habe ja teile gelöscht aber das Programm 
funktioniert einwandfrei auch mit gotos. Es macht das was ich will und 
es braucht diese auch. Das einzige was ich möchte ist das know-how, wie 
man Teile auslagert da ich diese mehrmals brauche. Auch die Version oben 
ist gerade auf einem ATMEGA88p und an und abschalten klappt.

[Peter II (Gast)]

Alain F. schrieb:
> Lieber Peter II, ich habe ja teile gelöscht aber das Programm
> funktioniert einwandfrei auch mit gotos

ich sage ja nicht das es nicht funktioniert oder fehlerhaft ist. Es ist 
nicht mehr wartbar. Mit diesen goto geht es ebend nicht das in 
funktionen auszulagern. Du bist jetzt an einem punkt wo das Progamm 
immer schlimmer wird und du führer oder später nicht mehr duchsiehst.

Wenn du ohne gotos arbeitest hättest du gleich ein saubere Programm 
aufbau und das auslagern von funktionen geht dann auch.

Sieht als lernphase an, die (fast)jeder schon durchgemacht hat.

[Alain F. (fox82)]

Programmiertechnisch und Übersichtlich wäre es von Vorteil. Ich kann die 
selben Stellen auch mehrmals kopieren aber das beeinträchtigt die 
Übersichtlichkeit und die Fehler bei Änderungen sind grösser.

Es muss doch eine vernünftige Lösung dafür geben.

[Klaus Dieter (Gast)]

Alain F. schrieb:
> Es muss doch eine vernünftige Lösung dafür geben.

Die gibt es: Ordentlich programmieren, ohne gotos!

[Alain F. (fox82)]

OK ignorieren wir mal die gotos. beim obigen Code kann man da auch 
darauf verzichten, weil die Sprünge im Sleep eh nicht gebraucht werden.

Auch ohne gotos kommt diese Meldung:
Build started 7.4.2012 at 00:20:06
avr-gcc  -mmcu=atmega88p -Wall -gdwarf-2 -std=gnu99 
-DF_CPU=2000000UL -Os -funsigned-char -funsigned-bitfields -fpack-struct 
-fshort-enums -MD -MP -MT ATMEGA8.o -MF dep/ATMEGA8.o.d  -c 
../ATMEGA8.c
../ATMEGA8.c: In function 'sleep_p':
../ATMEGA8.c:45:1: error: 'On' undeclared (first use in this function)
../ATMEGA8.c:45:1: note: each undeclared identifier is reported only 
once for each function it appears in
../ATMEGA8.c:48:1: warning: large integer implicitly truncated to 
unsigned type
../ATMEGA8.c:49:1: warning: large integer implicitly truncated to 
unsigned type
../ATMEGA8.c: In function 'main':
../ATMEGA8.c:115:5: warning: unused variable 'DIM_value'
../ATMEGA8.c:114:5: warning: unused variable 'Modus'
../ATMEGA8.c:113:5: warning: unused variable 'x'
make: *** [ATMEGA8.o] Fehler 1
Build failed with 1 errors and 5 warnings...
 wenn ich diesen code habe:

#include <avr/io.h>
#include <avr/interrupt.h>
#include <inttypes.h>
#include <avr/pgmspace.h>
#include <avr/wdt.h>
#include <avr/sleep.h>
#include <math.h>
#include <avr/eeprom.h>


#define F_CPU 2000000UL     /* Quarz mit 8.0Mhz */
#include <util/delay.h>



#define Enable    (1<<PD5)
#define PWM      (1<<PB1)



#define Taster_INT0  (1<<PD2)
// PinB5 ON = Never off UnderVoltageCutOut OFF
// PinB4 ON = Power on on Voltage


        #define fosc 2000000      //Taktfrequenz in Hz 
        #define UpperLimit   (unsigned int) (fosc*0.0022)  // Anzahl Ticks für 2,2ms
        #define LowerLimit   (unsigned int) (fosc*0.0008)  // Anzahl Ticks für 0,8ms
        #define Middle     (unsigned int) (fosc*0.0015)  // Anzahl Ticks für 1,5ms


//************************************************************************
//------------------------------------------------------------------------
//************************************************************************
//------------------------------------------------------------------------
//                          Hauptprogramm
//------------------------------------------------------------------------
//************************************************************************
//------------------------------------------------------------------------
//************************************************************************


void sleep_p() {
EIMSK |= (1 << INT0);  // Interupt auf INT0 freigeben
On = 0;
PORTD&=~Enable;
ADMUX = 0b00000000;    // Internal Reference Disabled
ADCSRA = ~(1<<ADEN); //ADC Disable = Stromsparen 0.3mA
TCCR1A = ~(1<<COM1A1); // Disable PWM
//wdt_disable(); // Watchdog ausaschalten
_delay_ms(150);
set_sleep_mode(SLEEP_MODE_PWR_DOWN);
sleep_mode();
}



int main (void) {   

 


//------------------------------------------------------------------------
//            PORTX DDRX
//------------------------------------------------------------------------
   DDRB  = 0b00111110;            //0= Eingang; 1 = Ausgang
   PORTB = 0b00111110;            //0= act. Low; 1 =act. High

   DDRC  = 0b00000000;            //0= Eingang; 1 = Ausgang
   PORTC = 0b00000000;            //0= act. Low; 1 =act. High
   
   DDRD  = 0b11110011;            //0= Eingang; 1 = Ausgang
   PORTD = 0b01001100;            //0= act. Low; 1 =act. High   
   

//------------------------------------------------------------------------
//            ADMUX-Register
//------------------------------------------------------------------------

  ADMUX = 0b00000000;        // Für interne Referenzspannung   ADMUX = 0b11000000; 88P = Internal 1.1V Voltage Reference with external capacitor at AREF pin
                          // auch ADMUX = 2; (Kanalnummer) oder ADMUX = 0b00000010;
  ADCSRA = 1<<ADEN | 1<<ADPS2 | 1<<ADPS1 | 1<<ADPS0;    // Initialisierung des ADC über das ADCSRA-Register
//  ADCSRA = 10000111


//------------------------------------------------------------------------
//            PWM Register 
//------------------------------------------------------------------------

TCCR1A = (1<<WGM10)|(1<<COM1A1)|(1<<COM1B1) ; // 8bit PWM-Modus, nicht invertiernde PWM
TCCR1B = (1<<CS11);             // PWM-Signal Takt Clock / 8 = 500Hz  (LM3421 max 50kHz)

//------------------------------------------------------------------------
//            Interrupt
//------------------------------------------------------------------------

    ACSR = 0x80;      // Analogcomparator ausschalten
    MCUCR &= ~00000011;     // levelgesteuerter Interrupt an INT0
    sei();          // Interrupts freigeben

//------------------------------------------------------------------------
//            Watch Dog
//------------------------------------------------------------------------

// wdt_enable(WDTO_500MS);

//------------------------------------------------------------------------
//             Variablen deklarieren
//------------------------------------------------------------------------

int On = 1;
int x1 =0;
int x = 0;
int Modus = 1;
int DIM_value = 100;
int32_t Taster_Time =0;
int Sleep_c = 1;


//************************************************************************
//------------------------------------------------------------------------
//                          Hauptschleife
//------------------------------------------------------------------------
//************************************************************************

//if ( !(PINB & (1<<PINB4)) ){
goto Jump_ON;

//}

 while(1){    

//Sleep_c = 0;


x1 = x1 + 1;

//------------------------------------------------------------------------
//             Watch Dog
//------------------------------------------------------------------------

//  wdt_reset();


//------------------------------------------------------------------------
//             Clock Speed
//------------------------------------------------------------------------
/*
The CLKPCE bit must be written to logic one to enable change of the CLKPS bits. The CLKPCE
bit is only updated when the other bits in CLKPR are simultaneously written to zero. CLKPCE is
cleared by hardware four cycles after it is written or when CLKPS bits are written. Rewriting the
CLKPCE bit within this time-out period does neither extend the time-out period, nor clear the
CLKPCE bit.
*/
CLKPR = 0b10000000; 

CLKPR = 0b00000010; // Clock divided / 4 = 2 Mhz


// ___________OCR1A Register für PWM Signal ___________________


  OCR1A = 1023; //White

//____________________________________________________




// ---------------- Anschalten (Aufstarten) ------------------
if ( !(PIND & Taster_INT0 ) & (On == 0) ) {
Jump_ON:; //Jump_DIM Marker 
sleep_disable();
//wdt_enable(WDTO_500MS);
Sleep_c = 0;

EIMSK &= ~(1 << INT0);
ADMUX = 0b11000000;    // Internal Reference Enabled    

ADCSRA = 1<<ADEN | 1<<ADPS2 | 1<<ADPS1 | 1<<ADPS0;    

On = 1;
PORTD|=Enable;
_delay_ms(150);

}



// ---------------- Ausschalten (Sleepmodus) ------------------
Taster_Time = 0;

while ( !(PIND & Taster_INT0 ) & (On == 1) ) {

Sleep_c = 1;
}


// ---------------- uC geht schlafen ------------------
if (Sleep_c == 1) {
void Sleep_p();

}


if (Sleep_c == 0) {

}


}
}

ISR(INT0_vect) { // Interupt Rutine kann leer sein muss aber existieren
}

[Klaus Dieter (Gast)]

Du hast die Variable "On" nicht definiert...

[Alain F. (fox82)]

kann man die global definieren?

[Walter S. (avatar)]

Alain F. schrieb:
> ../ATMEGA8.c:45:1: error: 'On' undeclared (first use in this function)

aber dein Butterbrot kannst du schon selber schmieren?

Sorry, aber das musste sein

[Alain F. (fox82)]

@Walter S.: Nein das mach mein Roboter für mich! Machst du das etwa noch 
immer selber?


So konnte das zwar Compilieren und Brennen, aber das Programm 
funktioniert so nicht mehr.

#include <avr/io.h>
#include <avr/interrupt.h>
#include <inttypes.h>
#include <avr/pgmspace.h>
#include <avr/wdt.h>
#include <avr/sleep.h>
#include <math.h>
#include <avr/eeprom.h>


#define F_CPU 2000000UL     /* Quarz mit 8.0Mhz */
#include <util/delay.h>



#define Enable    (1<<PD5)
#define PWM      (1<<PB1)



#define Taster_INT0  (1<<PD2)
// PinB5 ON = Never off UnderVoltageCutOut OFF
// PinB4 ON = Power on on Voltage


        #define fosc 2000000      //Taktfrequenz in Hz 
        #define UpperLimit   (unsigned int) (fosc*0.0022)  // Anzahl Ticks für 2,2ms
        #define LowerLimit   (unsigned int) (fosc*0.0008)  // Anzahl Ticks für 0,8ms
        #define Middle     (unsigned int) (fosc*0.0015)  // Anzahl Ticks für 1,5ms


//************************************************************************
//------------------------------------------------------------------------
//************************************************************************
//------------------------------------------------------------------------
//                          Hauptprogramm
//------------------------------------------------------------------------
//************************************************************************
//------------------------------------------------------------------------
//************************************************************************


void sleep_p() {
EIMSK |= (1 << INT0);  // Interupt auf INT0 freigeben
PORTD&=~Enable;
ADMUX = 0b00000000;    // Internal Reference Disabled
ADCSRA = ~(1<<ADEN); //ADC Disable = Stromsparen 0.3mA
TCCR1A = ~(1<<COM1A1); // Disable PWM
//wdt_disable(); // Watchdog ausaschalten
_delay_ms(150);
set_sleep_mode(SLEEP_MODE_PWR_DOWN);
sleep_mode();
}



int main (void) {   

 


//------------------------------------------------------------------------
//            PORTX DDRX
//------------------------------------------------------------------------
   DDRB  = 0b00111110;            //0= Eingang; 1 = Ausgang
   PORTB = 0b00111110;            //0= act. Low; 1 =act. High

   DDRC  = 0b00000000;            //0= Eingang; 1 = Ausgang
   PORTC = 0b00000000;            //0= act. Low; 1 =act. High
   
   DDRD  = 0b11110011;            //0= Eingang; 1 = Ausgang
   PORTD = 0b01001100;            //0= act. Low; 1 =act. High   
   

//------------------------------------------------------------------------
//            ADMUX-Register
//------------------------------------------------------------------------

  ADMUX = 0b00000000;        // Für interne Referenzspannung   ADMUX = 0b11000000; 88P = Internal 1.1V Voltage Reference with external capacitor at AREF pin
                          // auch ADMUX = 2; (Kanalnummer) oder ADMUX = 0b00000010;
  ADCSRA = 1<<ADEN | 1<<ADPS2 | 1<<ADPS1 | 1<<ADPS0;    // Initialisierung des ADC über das ADCSRA-Register
//  ADCSRA = 10000111


//------------------------------------------------------------------------
//            PWM Register 
//------------------------------------------------------------------------

TCCR1A = (1<<WGM10)|(1<<COM1A1)|(1<<COM1B1) ; // 8bit PWM-Modus, nicht invertiernde PWM
TCCR1B = (1<<CS11);             // PWM-Signal Takt Clock / 8 = 500Hz  (LM3421 max 50kHz)

//------------------------------------------------------------------------
//            Interrupt
//------------------------------------------------------------------------

    ACSR = 0x80;      // Analogcomparator ausschalten
    MCUCR &= ~00000011;     // levelgesteuerter Interrupt an INT0
    sei();          // Interrupts freigeben

//------------------------------------------------------------------------
//            Watch Dog
//------------------------------------------------------------------------

// wdt_enable(WDTO_500MS);

//------------------------------------------------------------------------
//             Variablen deklarieren
//------------------------------------------------------------------------

static int On = 1;
int x1 =0;
int x = 0;
int Modus = 1;
int DIM_value = 100;
int32_t Taster_Time =0;
int Sleep_c = 1;


//************************************************************************
//------------------------------------------------------------------------
//                          Hauptschleife
//------------------------------------------------------------------------
//************************************************************************

//if ( !(PINB & (1<<PINB4)) ){
goto Jump_ON;

//}

 while(1){    

//Sleep_c = 0;


x1 = x1 + 1;

//------------------------------------------------------------------------
//             Watch Dog
//------------------------------------------------------------------------

//  wdt_reset();


//------------------------------------------------------------------------
//             Clock Speed
//------------------------------------------------------------------------
/*
The CLKPCE bit must be written to logic one to enable change of the CLKPS bits. The CLKPCE
bit is only updated when the other bits in CLKPR are simultaneously written to zero. CLKPCE is
cleared by hardware four cycles after it is written or when CLKPS bits are written. Rewriting the
CLKPCE bit within this time-out period does neither extend the time-out period, nor clear the
CLKPCE bit.
*/
CLKPR = 0b10000000; 

CLKPR = 0b00000010; // Clock divided / 4 = 2 Mhz


// ___________OCR1A Register für PWM Signal ___________________


  OCR1A = 100; //White

//____________________________________________________




// ---------------- Anschalten (Aufstarten) ------------------
if ( !(PIND & Taster_INT0 ) & (On == 0) ) {
Jump_ON:; //Jump_DIM Marker 
sleep_disable();
//wdt_enable(WDTO_500MS);
Sleep_c = 0;

EIMSK &= ~(1 << INT0);
ADMUX = 0b11000000;    // Internal Reference Enabled    

ADCSRA = 1<<ADEN | 1<<ADPS2 | 1<<ADPS1 | 1<<ADPS0;    

On = 1;
PORTD|=Enable;
_delay_ms(150);

}



// ---------------- Ausschalten (Sleepmodus) ------------------
Taster_Time = 0;

while ( !(PIND & Taster_INT0 ) & (On == 1) ) {

Sleep_c = 1;
}


// ---------------- uC geht schlafen ------------------
if (Sleep_c == 1) {
On=0;
void Sleep_p();
}


if (Sleep_c == 0) {

}


}
}

ISR(INT0_vect) { // Interupt Rutine kann leer sein muss aber existieren
}

[Klaus Dieter (Gast)]

Was soll das static da?

[Alain F. (fox82)]

Ach, das ist von einem Test. Der sollte nicht sein... ich bin langsam 
müde.
Egal auch wenn ich das static weg mache dann klappt das Programm nicht 
mehr richtig.

[Klaus Dieter (Gast)]

Deklariere die Variable mal außerhalb der Main-Funktion.