Zitat:

---

Original von MaikG:

Das was ich per Mach Datenblatt kenne ist verhältnissmäßig premitiv
und sowas komplexes wie die Customchips nachzubilden...

---

Zitat:

---

Original von MaikG:
Es geht ja um Umgebungswärme, die wird durch Kühlkörper nur verteilt
aber nicht vermieden.

---

Zitat:

---

Original von MaikG:

Da er bestimmt kein Chiphersteller für neue Customchips hat,
werden diese in anderen Chips(ähnlich Minimig) Emuliert werden
und die werden meistens warm bis heiss.

---

Was verstehst Du hier unter "emuliert"?

Bei solchen Systemen (wie auch z.B. Minimig) werden die Customchips komplett auf einem Fpga nachgebildet. Und das geht heutzutage so gut, daß diese Nachbildung dem Original in nichts nachsteht (abgesehen von den höheren Kosten).

So weit ich das mitbekommen habe, geht Natami sogar noch einen Schritt weiter und erweitert die Fähigkeiten der original-Chipsets sogar noch.
--
http://www.norman-interactive.com

Zitat:

---

Original von MaikG:
>Die vorletzte Revision konnte ja AFAIK schon 66 MHz passiv gekühlt.

Nicht auf BPPC/CPPC. Dabei würde die Rev.5 CPU 60°C überschreiten
(ausserhalb meines geschmacks). Evtl. freistehend.

---

Zitat:

---

Original von Andreas_Wolf:
> eine bestimmte Version des Motorola 68060, welche eigentlich für 50 Mhz
> ausgelegt ist soll man angeblich problemlos mit 100 Mhz betreiben
> können, was ich allerdings stark bezweifle

"Problemlos mit 100 MHz" ist zwar übertrieben, aber 90 MHz sind garantiert (siehe mein Beitrag vom 12.03.2008, 1.23 Uhr).

> Und da es noch keiner gemacht hat

Doch, Rodolphe Czuba (siehe genannter Beitrag). Und Thomas Hirsch will dem (zumindest bis 90 MHz) beim Natami folgen, was auch hier bereits im Thread diskutiert wurde.

---

Zitat:

---

Original von huepper:

Statt hier sinnfrei über unverständliche Formeln zu grübeln macht euch doch mal Gedanken ums Wetter oder ähnlich spannende Dinge ...

---

Zitat:

---

CPU's sind nun mal zum übertakten da, no risk no fun. (gilt nicht für die alten CPU's !!! )

---

Mir machen die Leute echt Sorgen, die ihre Classic-Hardware - an der doch soviel Herzblut klebt - ohne Sinn und Verstand im wahrsten Sinne des Wortes verheizen.

In einschlägigen Foren kursieren schon Listen, welche Übertaktungen angeblich möglich sein sollen. z.B. eine bestimmte Version des Motorola 68060, welche eigentlich für 50 Mhz ausgelegt ist soll man angeblich problemlos mit 100 Mhz betreiben können, was ich allerdings stark bezweifle - vor allem auf gängigen Amiga-Turbokarten.

Und da es noch keiner gemacht hat, kursieren dann ominöse Benchmarks, in denen auf Basis bestehender Benchmarks die Leistungsdaten bei imaginären Taktfrequenzen "hochgerechnet" werden. Wohl bemerkt: MIPS oder Mega Flops, aber nicht Ampere oder Watt!

Das fatale daran ist, daß der eine oder andere Hobbybastler durch solche Berichte zur Nachahmung verleitet wird. Als Ergebnis findet man dann im bekannten Internet-Auktionshaus missglückte Bastelversuche. Ist echt traurig sowas.

--
http://www.norman-interactive.com

Zitat:

---

Original von GMKai:
Das mit den 24-Bit-Screens lässt mich nicht los...
Im Aminet
http://aminet.net/dev/misc/CGraphX-DevKit.lha
gibts das entspr. SDK.
Ich habe bei mir CubicIDE installiert, wie kann ich dieses und für die Zukunft auch andere SDKs da einbinden?

---

Zitat:

---

Original von AmigaAlliance:

also vll. mag das ja auf 060 CPU's greifen mit deiner Formel: höherer Takt=mehr Wärme. Aber beziehe das nicht generell auf alle CPU's. Da Designveränderungen einen höheren Takt erlauben bei niedriger!! Abwärme. Bsp. CPU 1 braucht 1.4V und CPU2 nur 1.2V jeweils bei gleichem Takt. Was ziehen wir daraus??? Ganz einfach die konstante variable wird aufgelöst und CPU2 wird nicht so warm!!!

---

Zitat:

---

Original von MaikG:
Das eine höher getaktete CPU mehr wärme abgibt hat er ja aktzeptiert.
Nun, woher kommt denn wohl ebend die zusätzliche Wärme?

Wenn die aus dem nichts käme hätten wir alle keine hohen
Heizkostenabrechnungen...

---

Wenn das so wäre, dann würden alle nurnoch mit Strom heizen. Vielleicht findet sich ja ein Tüftler, der ein paar CPUs zu einem Heizkörper zusammenlötet.
--
http://www.norman-interactive.com

[ Dieser Beitrag wurde von Mad_Dog am 19.05.2008 um 17:25 Uhr geändert. ]

Zitat:

---

Original von AmigaAlliance:

Schon mal von von Designverbesserungen gehört? Siehe AMD welche mit niedrige "45nm" Core mehr MHZ bei niedriger VCore bereitstellen können als z.b. mit einer "90nm" Core CPU. Also sorry aber deine Darstellung mehr MHZ=mehr Strombedarf=mehr Wärme lasse ich so nicht gelten!

---

Zitat:

---

Original von AmigaAlliance:
@ MadDog
Und wieso soll eine höher getaktete CPU mehr Strom ziehen als eine niedrig getaktete??

---

Zitat:

---

Original von AmigaAlliance:
Und die Lebensdauer kratzt das auch nicht. Die 060 CPU's im aktuellen Stepping können bis 100MHZ getaktet werden mein Freund.

---

Zitat:

---

Original von MaikG:
>Benutz lieber fd2pragma aus dem Aminet.

Und wie benutzt man das?

Da kommt ständig so ein blöder Requester, der nach irgendwelchen
Buchstaben+Optionen fragt. Ich will doch nur eine fd zu bmap wandeln.

---

Zitat:

---

Original von MaikG:

Vielleicht ist es besser einfach ein Dynamisches LONG Array zu
nehmen und da die Speicheradressen reinzupacken.

---

Zitat:

---

Original von woop:

Zitat:

---

Original von Mad_Dog:

Wenn das korrekt ist, dann kann ich es auch anderen Usern als Beispielcode anbieten.

---

Uhm, ohne dir zu nahe treten zu wollen, aber _dazu_ solltest du deine Beispiele noch ein wenig überarbeiten so dass z.B. Fehler sauber abgefangen werden und alle Ressourcen wieder freigegeben werden.

---

Stimmt natürlich auch wieder.

Ein typisches Beispiel dafür, was passieren kann, wenn man sich auf eine Maschine verlässt. Dazu mußt Du wissen, daß ich diese Beispiele mit StormC gemacht habe. Und aus Faulheit kommt man eben dann zwangsläufig auf den Gedanken "wenn der Resource-Tracker nach Beendigung des Programms nicht meckert, wird's schon o.k. sein". Da kann es schonmal passieren, daß man etwas übersieht, bzw. sich auf gewisse Automatismen verlässt.

--
http://www.norman-interactive.com

Zitat:

---

Original von woop:

4. Statt der Warte-for-Schleife ist ein Delay(25); hier viel schöner und aussagekräftiger: "Obwohl der Kindprozess schläft kann der Elternprozess wegen der gelockten Semaphore nicht weitermachen."

---

Zitat:

---

Original von woop:
@Mad_Dog:

Auch dein Semaphorenbeispiel sieht funktionstüchtig aus

---

Klar - funktionieren tut's. Aber zur Sicherheit lass ich es nochmal Leute sehen die (hoffentlich) mehr Erfahrung in Sachen Exec haben, als ich. Schließlich kann man auch Betriebssystemmechanismen in einer Weise anwenden, wie es sich er Erfinder eigentlich nicht gedacht hat (z.B. weil man es nicht richtig verstanden hat) und es funktioniert (mehr oder weniger zufällig) trotzdem.

Wenn das korrekt ist, dann kann ich es auch anderen Usern als Beispielcode anbieten.


--
http://www.norman-interactive.com

c code:

---

/*  Prozesse.c
 *  Ein Multitasking Beispiel
 *
 *  Autor: Norman Walter
 *  Datum: 27.5.2006
 *
 *  Ein Hauptprozeß startet einen Kindprozeß.
 *  Die gemeinsam genutzte Resource - das Konsolenfenster - wird
 *  über eine Semaphore geschützt. Die beiden Prozesse kommunizieren
 *  dabei über den MessagePort des Hauptprozesses. Der Kindprozeß setzt
 *  eine Nachricht ab, sobald er fertig ist. Auf diese Nachricht wartet
 *  der Hauptprozeß, bevor er sich beendet.
 *
 */

#include <stdio.h>
#include <stdlib.h>

#include <exec/types.h>
#include <exec/semaphores.h>
#include <dos/dostags.h>

#include <clib/exec_protos.h>
#include <clib/dos_protos.h>
#include <clib/alib_protos.h>

struct ReadyMessage {
  struct Message rdy_Msg;
  BOOL Ready;
};

struct Process *mainprocess, *childprocess;
BPTR output;
struct SignalSemaphore *LockSemaphore;

void child(void)
{
  unsigned long i,j;
  struct MsgPort *port;
  struct ReadyMessage *rdy;

  if (rdy = (struct ReadyMessage *) AllocMem(sizeof(struct ReadyMessage), MEMF_PUBLIC | MEMF_CLEAR))
  {
     rdy->rdy_Msg.mn_Node.ln_Type = NT_MESSAGE;
     rdy->Ready = TRUE;
  }

  ObtainSemaphore(LockSemaphore);

  PutStr("Kindprozeß gestartetn");
  Flush(Output());

  for (i=0;i<20;i++)
  {
     for (j=0;j<5000000;j++);
     PutStr(".");
     Flush(Output());
  }

  PutStr("n");

  Forbid();
  port=FindPort("MainPort");

  if (port)
  {
     PutStr("Kindprozeß setzt Nachricht abn");
     Flush(Output());
     PutMsg(port,(struct Message *)rdy);
  }
  else
  {
     printf("Fehler: Konnte MainPort nicht findenn");
  }

  Permit();

  PutStr("Kindprozeß endetn");
  Flush(Output());

  ReleaseSemaphore(LockSemaphore);

}

int main (void)
{
  struct MsgPort *port;
  struct ReadyMessage *reply;

  port = CreateMsgPort();
  if (port)
  {
     port->mp_Node.ln_Name="MainPort";
     port->mp_Node.ln_Pri=0;
     AddPort(port);
  }
  else
  {
     printf("Fehler: Konnte MainPort nicht erzeugenn");
  }

  /* Semaphore zum Schützen des Konsolenfensters */
  LockSemaphore = AllocMem(sizeof(struct SignalSemaphore),MEMF_ANY);
  InitSemaphore(LockSemaphore);

  /* Den Hauptprozess finden */
  mainprocess = (struct Process *)FindTask(NULL);

  /* Öffne Konsolenfenster für Ausgabe */
  output = Open("*",MODE_OLDFILE);

  if(output==NULL)
  {
     printf("Fehler: Konnte Konsole nicht öffnenn");
  }
  else

  printf("Hauptprozeß gestartetn");

  /*  Kindprozeß starten:
   *  Falls dieser eine höhere Priorität wie der Hauptprozeß hat,
   *  verdrängt der Kindprozeß den Hauptprozeß (preemtives Multitasking)
   */
  childprocess = CreateNewProcTags( NP_Entry, child,    // Code
                                    NP_Name, "child",   // Name
                                    NP_Output, output,  // Ausgabe
                                    NP_Priority, 0,     // Priorität
                                    TAG_DONE
                                  );
  if (childprocess)
  {
     /*  Falls der Kindprozeß eine höhere Priorität wie der Hauptprozeß
      *  hat, wird dieser zuerst die Semaphore setzen und die
      *  Ausgabe erfolgt erst, wenn er die Semaphore wieder freigegeben hat
      */
     ObtainSemaphore(LockSemaphore);
     PutStr("Hauptprozeß versucht etwas auf die Konsole zu schreibenn");
     ReleaseSemaphore(LockSemaphore);
  }
  else
  {
     printf("Fehler: Konnte Kindprozeß nicht startenn");
  }

  /*  Der Hauptprozeß wartet nun auf Nachricht vom Kindprozeß */
  WaitPort(port);

  if (reply = (struct ReadyMessage *)GetMsg(port))
  {
     printf("Die Nachricht enthält: %ldn",reply->Ready);
  }

  printf("Hauptprozeß endetn");

  if (port) RemPort(port);
  if (LockSemaphore) FreeMem(LockSemaphore,sizeof(struct Semaphore));

  return 0;
}

---

Ich hoffe, daß ich dabei alles richtig gemacht habe?

--
http://www.norman-interactive.com

Zitat:

---

Bei Basic hat man an sich ja keine Pointer.
Das sind Long Intergers mit einem Wert.

---

c code:

---

#include <stdio.h>
#include <stdlib.h>

#include <exec/types.h>
#include <exec/semaphores.h>
#include <dos/dostags.h>

#include <clib/exec_protos.h>
#include <clib/dos_protos.h>
#include <clib/alib_protos.h>

struct ReadyMessage {
  struct Message rdy_Msg;
  BOOL Ready;
};

struct Process *mainprocess, *childprocess;
BPTR output;

ULONG i;

void child(void)
{
  ULONG j;

  struct MsgPort *port;
  struct Message *Msg;

  port = CreateMsgPort();
  if (port)
  {
     port->mp_Node.ln_Name="ChildPort";
     port->mp_Node.ln_Pri=0;
     AddPort(port);
  }

  while (!(Msg = GetMsg(port)))
  {
    PutStr("Kindprozeß aktiv!n");
    Delay(50);
  }

  //ReplyMsg(Msg);

  RemPort(port);
  DeleteMsgPort(port);

}

int main (void)
{
  struct MsgPort *port;
  struct ReadyMessage *rdy;

  if (rdy = (struct ReadyMessage *) AllocVec(sizeof(struct ReadyMessage), MEMF_PUBLIC | MEMF_CLEAR))
  {
     rdy->rdy_Msg.mn_Node.ln_Type = NT_MESSAGE;
     rdy->Ready = TRUE;
  }

  /* Den Hauptprozess finden */
  mainprocess = (struct Process *)FindTask(NULL);

  /* Öffne Konsolenfenster für Ausgabe */
  output = Open("*",MODE_OLDFILE);

  /*  Kindprozeß starten:
   *  Falls dieser eine höhere Priorität wie der Hauptprozeß hat,
   *  verdrängt der Kindprozeß den Hauptprozeß (preemtives Multitasking)
   */
  childprocess = CreateNewProcTags( NP_Entry, child,    // Code
                                    NP_Name, "child",   // Name
                                    NP_Output, output,  // Ausgabe
                                    NP_Priority, 0,     // Priorität
                                    TAG_DONE
                                  );
  Delay(250);

  Forbid();
  port=FindPort("ChildPort");

  if (port)
  {
    PutStr("ChildPort gefundenn");
    PutMsg(port,(struct Message *)rdy);
  }

  Permit();

  Delay(250);

  FreeVec(rdy);

  PutStr("Programmenden");

  return 0;
}

---

Zitat:

---

Original von MaikG:
>Wo ist das Problem? Du kannst, wenn Du willst auch sofort
>aussteigen, wenn Dir recv() -1 liefert:

Ja, schon. Aber ist es nicht besser es nochmal zu probieren?
Vielleicht kommt ja beim 2. mal etwas.

---

code:

---

try = 0  Rem Zähler für Versuche
t!=TIMER:laenge&=0
         WHILE TIMER-t!<5 AND try<5
          puffer&=Recv(fd&,MyMemory&+laenge&,1, MSG_PEEK%)
          IF puffer&>0 THEN
	    IF laenge&+puffer&>maxlaenge& THEN EXIT WHILE
            position&=Recv(fd&,MyMemory&+laenge&,puffer&, 0)
            
            Rem Falls recv fehlschlägt, Zähler hochzählen
            IF position%=-1 THEN try=try+1
            ELSE try=0

	    laenge&=laenge&+position&
	  ELSEIF puffer&=0 AND laenge&>0 THEN EXIT WHILE
          ELSE delay 1
          END IF
         WEND

---

Zitat:

---

>Der Overhead, den ich angesprochen habe, bezieht sich nur auf den
>Speicherbedarf. Sicher, Du mußt bei derser Methode zur Laufzeit
>ständig Speicher beschaffen und die Knoten in die Liste einhängen.
>Aber der "Rechenaufwand" (es wird ja nicht wirklich etwas dabei
>gerechnet, sondern es finden nur ein paar Zuweisungen statt)
>ist zu verschmerzen.

Unter Basic könnte das im ungünstigsten Falle schon um einiges
länger dauern als in C.

---

Zitat:

---

Original von woop:

Der Message-Port fürs timer.device wird im Hauptprozess angelegt, aber im Kindtask per SendIO/WaitIO bedient. Das sig-bit des Kindtasks wird wohl noch entsprechend gesetzt obwohl es hier nicht sauber alloziert werden dürfte, aber das GetMsg() des Hauptprozesses kann die Message entfernen bevor WaitIO() das im Task für dich erledigt. Damit würde dann dein WaitIO deadlocken.

---

c code:

---

void Update(void)
{
   /*  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();

	while (1)
   {
     ReadFrame(sc);
     DrawScope(sc);
   }

}

---

Wobei ich mir jetzt noch was besseres anstelle der Endlosschleife einfallen lassen muß.
--
http://www.norman-interactive.com

Zitat:

---

Original von MaikG:

>Das Gequängel um den Fall, daß recv() -1
>zurückgibt, stimmt mich da arg nachdenklich, dabei brichst Du
>Dir nun wirklich keinen Zacken aus der Krone, wenn Du diesen
>Fall sauber abfängst. Ein oder zwei IF-Klauseln mehr, ist
>doch eigentlich ein Klacks, oder?

Kann ich machen. Aber ist das wirklich besser?
So probiert das Programm weiter, ist das nicht evtl. besser
als beim 1. Fehler abzubrechen?
Beim Lesen eine Diskette macht ADos auch 5 Retrys.

---

basic code:

---

t!=TIMER:laenge&=0
         WHILE TIMER-t!<5
          puffer&=Recv(fd&,MyMemory&+laenge&,1, MSG_PEEK%)
          IF puffer&>0 THEN
	    IF laenge&+puffer&>maxlaenge& THEN EXIT WHILE
            position&=Recv(fd&,MyMemory&+laenge&,puffer&, 0)
            
            Rem Falls recv fehlschlägt, aus der Schleife aussteigen
            IF position%=-1 THEN EXIT WHILE

	    laenge&=laenge&+position&
	  ELSEIF puffer&=0 AND laenge&>0 THEN EXIT WHILE
          ELSE delay 1
          END IF
         WEND

---

Zitat:

---

>Implementier es einfach. Wenn Du es einmal wirklich benutzt hast,
>dann wirst Du es schätzen lernen.

Ich glaube mit dem overhead würde ich den Support von langsameren
Prozessoren einfach killen.

---

Zitat:

---

Original von Maja:

Zitat:

---

Original von MaikG:
Nehmen wir einen Wassertonne, in die kontinuierlich Wasser reinläuft.
Wenn ich nicht immer mit der Gießkanne Wasser abnehme läuft diese
Über.

---

Jetzt nehme noch an, dieser Wassertonne gehört einem Wirt und neben der Wassertonne steht ein Weinfass. Das überlaufende Wasser läuft aus der Wassertonne in das Weinfass. Der Wein verwässert und der Wirt wird wegen Panscherrei verklagt.

---

Auch eine sehr schöne Analogie.

Fehlt nurnoch daß jemand kommt und mittels Typecast das Wasser zu Wein macht, dann passt wieder alles.

--
http://www.norman-interactive.com

[ Dieser Beitrag wurde von Mad_Dog am 04.05.2008 um 01:07 Uhr geändert. ]

Zitat:

---

Original von woop:
@Mad_Dog:

Damit verbrätst du natürlich 100% CPU aber das macht dein Kind-Task so ja auch schon

---

Nun ja "fast" 100%

ReadFrame() funktioniert so:

Ich lese einen Wert vom Parallelport, warte bis zur nächsten Periode lese wieder einen Wert usw. bis ich alle Werte habe.

Zum besseren Verständnis hier noch mein Include "scope.c":

c code:

---

/*  scope.c
 *
 */

#include "scope.h"

/*  Scope
 *
 *  Oszilloskop erzeugen:
 *
 *  Eingabeparameter: ULONG f  - Die Samplingfrequenz
 *                    double t - Dauer des Samples in Sekunden
 *                    LONG p   - Pen Nummer zum Zeichnen
 *                    LONG b   - Pen Nummer für Hintergrund
 *  Rückgabe:         struct Scope* - Zeiger auf Scope Struktur
 *
 */
struct Scope *CreateScope(struct Window *win, ULONG f,double t,LONG p, LONG b)
{
   struct Scope *sc;

   sc = (struct Scope *) AllocVec(sizeof(struct Scope),MEMF_CLEAR);

   sc->Window = win;

   sc->raster = AllocRasterBitmap((unsigned int)win->GZZWidth,(unsigned int)win->GZZHeight);
   SetColor(sc->raster,p);

   // Temporärern RastPort initialisieren
   sc->tmprp = *win->RPort;
   sc->tmprp.Layer = NULL;
   sc->tmprp.BitMap = AllocBitMap (win->GZZWidth,1,8,0,NULL);

   sc->SamplingFreq = f;
   sc->Time = t;
   sc->Period = (int)1E6/f;
   sc->Size = (ULONG)(f*t);
   sc->Data = (UBYTE *)AllocVec(sc->Size,MEMF_CLEAR);
   sc->Pen = p;
   sc->Background = b;
   sc->TimerMP = CreateMsgPort();
   sc->TimerIO = (struct timerequest *) CreateIORequest(sc->TimerMP,sizeof(struct timerequest));

   return sc; 
}

/*  FreeScope
 *
 *  Oszilloskop Struktur freigeben
 *
 *  Eingabeparameter struct Scope *sc - Zeiger auf Scope Struktur
 *  Rückgabe:        void
 *
 */ 
void FreeScope(struct Scope *sc)
{
   AbortIO((struct IORequest *)sc->TimerIO);
   WaitIO((struct IORequest *)sc->TimerIO);
   if (sc->TimerMP) DeleteMsgPort(sc->TimerMP);
   if (sc->TimerIO) DeleteIORequest((struct IORequest *)sc->TimerIO);
   FreeVec(sc->Data);
   FreeVec(sc);
   FreeRasterBitmap(sc->raster);
}


// Ein Zeitfenster lesen.
void ReadFrame(struct Scope *sc)
{
   unsigned int t;

   /*  Hier werden die Werte gesammelt
    */
   for (t=0;t<sc->Size;t++)
   {
      sc->TimerIO->tr_node.io_Command = TR_ADDREQUEST;
      sc->TimerIO->tr_time.tv_secs = 0;
      sc->TimerIO->tr_time.tv_micro = sc->Period;

      READ_PAR(sc->Data[t]);  // Wert vom Parallelport kopieren

      SendIO((struct IORequest *)sc->TimerIO);
      WaitIO((struct IORequest *)sc->TimerIO);

   }
}

/*  DrawScope
 *
 *  Zeichnet das Oszilloskop in ein Fenster
 *
 *  Eingabe: struct Scope  *sc  - Zeiger auf Oszilloskop Struktur
 */
void DrawScope(struct Scope *sc)
{
   register int t;
   register struct RastPort *rp;     // RastPort des Fensters
   register int zero;

   rp = sc->Window->RPort;

   //zero = sc->Window->GZZHeight/2;
   zero = 128;

   SetColor(sc->raster,sc->Background);
   ClearRaster(sc->raster);

   SetColor(sc->raster,sc->Pen);

   // Linien in Pixel Array eintragen
   for (t=0;t<sc->Size;t++)
   {
     rasterLine(sc->raster,t,zero,t,sc->Data[t]);
   }

   // Inhalt der Pixel Array auf RastPort des Fensters übertragen
   WritePixelArray8 (sc->Window->RPort,
	             0,0,
		     sc->Window->GZZWidth-1,sc->Window->GZZHeight-1,
		     (UBYTE *)sc->raster->data,
		     &sc->tmprp);

}

---

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;
}

---