Interrupt Handler control+C

Hi everybody.
I made a C program, but I'm having some doubts about how to implement an ISR. What I liked to do was that inside the loop instead of always opening and closing the files, write files only when made ^ C.
Can you help me?
Many thanks.

Code:

---

        while(1){
                logfile = fopen(filename, "a+");
                gpslogfile = fopen(filename2, "a+");


                if ((rs232res=read(rs232fd,rs232buf,MAXBUFLEN)) != -1)
                {
                        rs232buf[rs232res]='\0';
                        fprintf(gpslogfile, "%s\n", rs232buf);
                        strncpy(temp, rs232buf, 6);
                        temp[6] = '\0';
                        if(strcmp(temp, "$GPRMC") == 0)
                        {
                                strtok(rs232buf, ",");
                                xtime = strtok(NULL, ",");
                                strtok(NULL, ",");
                                xlat = strtok(NULL, ",");
                                xns = strtok(NULL, ",");
                                xlong = strtok(NULL, ",");
                                xew = strtok(NULL, ",");
                                fprintf(logfile, "--> %s - %s%s, %s%s\n", xtime, xlat, xns, xlong, xew);
                                printf("--> %s - %s%s, %s%s\n", xtime, xlat, xns, xlong, xew);
                                strncpy(lastxtime, xtime, 10);
                                lastxtime[10] = '\0';
                        }
                        rs232buf[0] = '\0';
                }


                /* PACKET CREATED BY THE CLIENT AND BROADCASTED  */
                sprintf(buf, "ID %d - time %s", msgID, lastxtime);

//                usleep(100000);

                time++;
                if (time >= WAITTIME)
                {
                        sendto(sockfdTX, buf, strlen(buf)*sizeof(char), 0, (struct sockaddr *)&their_addr, sizeof their_addr);
                        fprintf(logfile, "TX: ID %d - time %s - dest %s\n", msgID, lastxtime, inet_ntoa(their_addr.sin_addr));
                        printf("TX: ID %d - time %s - dest %s\n", msgID, lastxtime, inet_ntoa(their_addr.sin_addr));
                        msgID++;
                        time = 0;
                }


                fclose(logfile);
                fclose(gpslogfile);

                }

---

ISR? Last time I heard of them was in MS-DOS days, before windows 3 existed.

In any event, those things are very operating system and compiler/library specific.

Generally, however, it's a good idea to keep ISR as simple as possible. A common approach is for the ISR to set a flag, and for that flag to be checked in your processing loop and reset. For example, the flag might be a volatile int. The ISR sets it to non-zero value when CTRL-C is hit. Your loop writes to file when the value is non-zero and resets it to zero.

Depending on how you want your program to interact with the user, there are more modern approaches (eg a GUI with a worker thread).

Ok, thanks... it is so old? :)
But how can I transmit to the program that Im pressing ^C?
It is only necessary that in the console, when you click ^ C, the program finishes and close the file.
And in the loop how can I call de interrupt function?
Thanks again.

Are you /completely/ sure you want to handle is a processor interrupt and not something like a user level signal? If so, you got to tell which processor architecture you are programming for so anyone can say anything useful.

Yes, I would like to have a user level signal. How does it work?

If you're on UNIX or UNIX-ish system, check your systems (or POSIX which I linked) manual for signal.h, sigaction(2) and then refer to other manuals if needed. ^C raises normally SIGINT, sometimes it is configured to SIGTERM and can be configured to pretty much anything.

And if you're on Windows the venerable SetConsoleCtrlHandler (SetConsoleCtrlHandler Function (Windows)) will do the trick very nicely.

I can see what you mean by ISR as these are pretty much the same thing, with the only difference really being implementation and level of abstraction (the old ISRs were much closer to the hardware).