PIC16LF1509 for schleife bricht nicht ab

[Hans Jürgen (Gast)]

Hallo Leute,

ich habe eine LED die eine bestimmt Anzahl blinken soll. Dafür habe ich 
den Code unten geschrieben. Das Problem ist, dass sie durchgehend blinkt 
und nicht nur zehn mal. Warum bricht das Programm nicht irgendwann ab?

#include <xc.h>


/***** CONFIGURATION *****/
//  ext reset, internal oscillator (no clock out), no watchdog timer
#pragma config MCLRE = ON, FOSC = INTOSC, CLKOUTEN = OFF, WDTE = OFF
//  brownout resets enabled, low brownout voltage, no low-power brownout reset
#pragma config BOREN = ON, BORV = LO, LPBOR = OFF
//  no power-up timer, no code protect, no write protection
#pragma config PWRTE = OFF, CP = OFF, WRT = OFF
//  stack resets on, high-voltage programming
#pragma config STVREN = ON, LVP = OFF

#define _XTAL_FREQ  500000      // oscillator frequency for _delay()


/***** MAIN PROGRAM *****/
void main()
{
    //*** Initialisation

    // configure port
    LATA = 0;
    TRISA = 0;

    // configure oscillator
    OSCCONbits.SCS1 = 1;        // select internal clock
    OSCCONbits.IRCF = 0b0111;   // internal oscillator = 500 kHz


    //*** Main loop
    for (int i=0;i<10;i++)
    {
        LATA^=0x20;
        __delay_ms(500);

    }
}

Grüße
Hans und Jürgen

[Michael U. (amiga)]

Hallo,

was mag der PIC wohl machen, wenn er 10x geblinkt hat?
Wie bei µC-Umgebungen üblich die main() wieder von vorn beginnen?

Gruß aus Berlin
Michael

[Hans Jürgen (Gast)]

Hi,

danke Michael, bester Mann :D. Dann kann ich mir ja jetzt Gedanken über 
mein weiteres Vorgehen machen.
Schönen Tag noch.

Viele Grüße nach Berlin.

Hans und Jürgen

[Fabian (Gast)]

Davon abgesehen, blinkt die LED mit dem Code, sofern er danach nicht 
wieder von vorne beginnt, nur 5 mal...

[Erich (Gast)]

Vor der letzten schließenden Klammer }
reinschreiben:

{
  while(1);
}

Das hält den uC "an".

[Hans Jürgen (Gast)]

Hallo,

ja komisch. Bei mir blinkt die LED durchgehend. Sicher, dass der µc 
wieder von vorne beginnt?

[Klaus (Gast)]

Hans Jürgen schrieb:
> Sicher, dass der µc wieder von vorne beginnt?

Debugger, durchsteppen

MfG Klaus

[Volker S. (vloki)]

Hans Jürgen schrieb:
> Sicher, dass der µc
> wieder von vorne beginnt?

Was soll er denn sonst machen?

Hast du einen Debugger? PICkit3 oder so?
Dann setz einen Breakpoint auf die erste Zeile in main(),
wenn dein PIC ICD unterstützt. (Wenn nicht nimm den Simulator)

[S. Landolt (Gast)]

> Wie bei µC-Umgebungen üblich die main() wieder von vorn beginnen?

Dem möchte ich nicht ganz zustimmen, bei meinem avr-gcc hält der uC dann 
an per leerer Endlosschleife.

[Lothar M. (Firma: Titel) (lkmiller) (Moderator)]

S. Landolt schrieb:
> bei meinem avr-gcc hält der uC dann an per leerer Endlosschleife.
Ob das beim PIC auch so ist, könnte man einfach mit einem
for(;;);
oder
while(1);
vor der letzten Klammer ausprobieren...

[Hans Jürgen (Gast)]

Ich habe gelesen, dass man nicht genau sagen kann was der µc macht wenn 
man zum Programmende gekommen ist. Scheint wohl so, dass jeder Typ etwas 
anderes macht.

Also am besten den µc nicht zum Programmende kommen lassen?

Beste Grüße

H&J

[Lothar M. (Firma: Titel) (lkmiller) (Moderator)]

Hans Jürgen schrieb:
> Ich habe gelesen, dass man nicht genau sagen kann was der µc macht wenn
> man zum Programmende gekommen ist.
Man kann es recht genau sagen, wenn man sich den Startup-Code ansieht.

> Also am besten den µc nicht zum Programmende kommen lassen?
Natürlich nicht. Was sollte er denn nach dem "Programmende" machen, wenn 
trotzdem noch Versorgungspannung an ihm und dem gesamten Drumherum 
anliegt?

[Volker S. (vloki)]

Hans Jürgen schrieb:
> Ich habe gelesen, dass man nicht genau sagen kann was der µc macht wenn
> man zum Programmende gekommen ist. Scheint wohl so, dass jeder Typ etwas
> anderes macht.

Kleine Erläuterung zu Lothars Ausführungen. Nicht der uC macht das im 
allgemeinen, sondern der Compiler. Also kannst du im User Guide von 
diesem nachschauen was da genau passiert.

################################################################
5.10 MAIN, RUNTIME STARTUP AND RESET
The identifier main is special. You must always have one, and only one, 
function called main() in your programs. This is the first function to 
execute in your program.
Code associated with main(); however, is not the first code to execute 
after Reset.
Additional code provided by the compiler, and known as the runtime 
startup code, is executed first and is responsible for transferring 
control to the main() function. The actions and control of this code is 
described in the following sections.
The compiler inserts special code at the end of main() which is executed 
if this function ends, i.e., a return statement inside main() is 
executed, or code execution reaches the main()’s terminating right 
brace. This special code causes execution to jump to address 0, the 
Reset vector for all 8-bit PIC devices. This essentially performs a 
software Reset. Note that the state of registers after a software Reset 
can be different
to that after a hardware Reset.
It is recommended that the main() function does not end. Add a loop 
construct (such as a while(1)) that will never terminate either around 
your code in main() or at the end of your code, so that execution of the 
function will never terminate. For example,

void main(void)
{
// your code goes here
// finished that, now just wait for interrupts
    while(1)
    continue;
}
################################################################