Task schläft ein - amiga-news.de Forum

amiga-news.de Forum > Programmierung > Task schläft ein
[ - Search - New posts - Register - Login - ]
-1-
[ - Post reply - ]
2008-05-03, 19:44 h

Mad_Dog
Posts: 1944
User
Hallo,

Ich habe versucht bei meinem Programm "Monoscope" das Neuzeichnen der Grafik in einen extra Task zu packen (Funktion Update).

Der Fensterinhalt wird zwar eine Weile upgedatet, aber dann scheint der Task einzuschlafen.

Was mache ich falsch?

Hier das Hauptprogramm:
c code:
#include <stdio.h>
#include <stdlib.h>

#include <exec/types.h>
#include <exec/exec.h>
#include <exec/memory.h>
#include <exec/libraries.h>
#include <dos/dos.h>
#include <intuition/intuition.h>
#include <intuition/gadgetclass.h>
#include <graphics/gfx.h>
#include <libraries/gadtools.h>
#include <devices/timer.h>

#include <proto/exec.h>
#include <proto/dos.h>
#include <proto/intuition.h>
#include <proto/graphics.h>
#include <proto/gadtools.h>

#include <clib/alib_protos.h>

#include "requesters.h"
#include "requesters.c"
#include "menu.h"
#include "menu.c"
#include "parallel.h"             // Makros für CIA Low-Level Zugriff
#include "scope.h"
#include "scope.c"

#define WIDTH 400   // Breite des Fensters
#define HEIGHT 256  // Höhe des Fensters

struct Window *Fenster = NULL;               // Zeiger auf Window-Struktur
struct Screen *mysc = NULL;
struct IntuitionBase *IntuitionBase = NULL;  // Zeiger auf IntuitionBase-Struktur
struct GfxBase *GfxBase = NULL;              // Zeiger auf GfxBase-Struktur
struct Library *GadToolsBase = NULL;
void *vi = NULL;                             // Visual Info

struct Scope *sc;

struct Task *child = NULL;
char *childname = "Uptate Scope";

UBYTE TimerDevice;

UBYTE vers[] = "$VER: Monoscope 1.5";

// Resourcen freigeben
void ShutDown(void)
{
    if (mysc) UnlockPubScreen(NULL, mysc);
    if (GadToolsBase) CloseLibrary(GadToolsBase);
    if (Fenster) CloseWindow(Fenster);
    if (GfxBase) CloseLibrary((struct Library *) GfxBase);
    if (IntuitionBase) CloseLibrary((struct Library *) IntuitionBase);
}

extern void Update(void)
{
   while (1)
   {
     ReadFrame(sc);
     DrawScope(sc);
   }

}

int main(void)
{
   /* Variablen zur Message-Bearbeitung */
   struct MsgPort *Port;             // Zeiger auf Message Port Struktur
   struct IntuiMessage *Nachricht;   // Zeiger auf Intuition Message Struktur

   LONG black,green;  // Variablen für die Pen Nummern

   ULONG  klasse;
   USHORT code;

   BOOL Ende;

   Ende = FALSE;
   Freeze = FALSE;  // Anzeige einfrieren (TRUE/FALSE)

   // Intuition Library öffnen
   IntuitionBase = (struct IntuitionBase *) OpenLibrary("intuition.library",36L);
   if (IntuitionBase == NULL) ShutDown();

   GfxBase = (struct GfxBase *) OpenLibrary("graphics.library",0L);
   if (GfxBase == NULL) ShutDown();

   // GadTools Library öffnen
   GadToolsBase = OpenLibrary("gadtools.library", 37L);
   if (GadToolsBase == NULL) ShutDown();

   mysc = LockPubScreen(NULL);

   // Fenster mittels Tags öffnen
   Fenster = OpenWindowTags(NULL,
                            WA_Left, 100,    // Abstand vom linken Rand
                            WA_Top, 100,     // Abstand vom oberen Rand
                            WA_InnerWidth, WIDTH,    // Innere Breite
                            WA_InnerHeight, HEIGHT,  // Innere Höhe
                            WA_Title, "Monoscope",          // Fenstertitel
                            WA_ScreenTitle,"Monoscope V1.5 © 2008 by Norman Walter",
                            WA_CloseGadget, TRUE,           // Close-Gadget
                            WA_DragBar, TRUE,               // Ziehleiste
                            WA_DepthGadget, TRUE,           // Depth-Gadget
                            WA_GimmeZeroZero, TRUE,         // Ursprung 0/0
                            WA_NewLookMenus, TRUE,
                            WA_IDCMP,
                            IDCMP_CLOSEWINDOW | IDCMP_MENUPICK | IDCMP_INTUITICKS | IDCMP_REFRESHWINDOW,
                            WA_Activate, TRUE,              // Fenster aktivieren
                            TAG_DONE);

   if (Fenster==NULL) ShutDown();

   vi = GetVisualInfo(mysc, TAG_DONE);
   menu = CreateMenus(mynewmenu, TAG_DONE);
   LayoutMenus(menu, vi, GTMN_NewLookMenus, TRUE, TAG_DONE);
   SetMenuStrip(Fenster, menu);

   Port=Fenster->UserPort;

   /* Pens ermitteln: Schwarz und Grün */
   black = ObtainBestPen(Fenster->WScreen->ViewPort.ColorMap,
                         0x00000000,0x00000000,0x00000000,
                         OBP_Precision,PRECISION_GUI,
                         TAG_DONE);

   green = ObtainBestPen(Fenster->WScreen->ViewPort.ColorMap,
                         0x00000000,0xFFFFFFFF,0x00000000,
                         OBP_Precision,PRECISION_GUI,
                         TAG_DONE);

   /*  Oszilloskop erzeugen:
    *  32Khz Samplingrate,
    *  Zeitfenster 0.0125 Sekunden
    *  Zeichenfarbe grün, Hintergrund schwarz
    */
   sc = CreateScope(Fenster,32000,0.0125,green,black);

   /*  Wichtig: Für diesen Zweck brauchen wir UNIT_MICROHZ.
    *  Die anderen Timer sind zu ungenau.
    */
   TimerDevice = OpenDevice(TIMERNAME,UNIT_MICROHZ,(struct IORequest *)sc->TimerIO,0L);
   if (TimerDevice !=0) ShutDown();

   // Den Parallelport in den Lesemodus versetzen
   SET_PARALLEL_PORT_READ;

   child = CreateTask(childname,0L,Update,4000L);

   while (!Ende)
   {
      // Lese Zeitfenster
      //if (!Freeze) ReadFrame(sc);

      WaitPort(Port);

     /* Schleife läuft bis alle Ereignisse
      * abgearbeitet sind.
      */
      //while(Nachricht=(struct IntuiMessage *)GetMsg(Port))
      while((!Ende) && (Nachricht=GT_GetIMsg(Port)))
      {

        klasse = Nachricht->Class;
        code =  Nachricht->Code;
        GT_ReplyIMsg(Nachricht);

        /* Welches Ereignis ist eingetreten? */
        switch(klasse)
        {
          /* Close Gadget wurde angeklickt */
           case CLOSEWINDOW :
                Ende = TRUE; // Programmende
           break;

           case MENUPICK:
		          Ende = HandleMenuEvent(code);
		     break;

          /* Intuition hat sich gemeldet */
          case INTUITICKS :
               // Zeichne das Oszilloskop
               if (!Freeze)
               {
 						//Update();
               }
          break;

          case IDCMP_REFRESHWINDOW:
               GT_BeginRefresh(Fenster);
               GT_EndRefresh(Fenster,TRUE);
          break;

        } // Ende der switch-Verzweigung

       /* Wir sind mit der Bearbeitung fertig
        * und beantworten die Nachricht.
        */
       //ReplyMsg((struct Message *)Nachricht);

     }
   }

   Forbid();
   DeleteTask(child);
   Permit();

   // Die Pens wieder freigeben
   ReleasePen(Fenster->WScreen->ViewPort.ColorMap,black);
   ReleasePen(Fenster->WScreen->ViewPort.ColorMap,green);

   FreeScope(sc);

   ShutDown();

   return 0;
}
--
http://www.norman-interactive.com

[ Dieser Beitrag wurde von Mad_Dog am 03.05.2008 um 19:44 Uhr geändert. ]