Simulator für BER und modulierte Signale

Mit gnuplot kannste auch Formeln plotten. Falls du Latex zur 
Dokumentation verwendest (ist bei Wissenschaftlichen Arbeiten durchaus 
empfehlenswert) kannst du gnuplot sogar direkt einbinden.

Falls er jedoch den Berliner Flughafen meinen sollte, hätte ich hier 
einen Ansatz:

void main (void)
{
  while (1)
  {
    waitJahre (5);
  }
}

@Marek N.:

Ich weiß gar nicht so richtig, womit ich die machen soll. Ich habe da 
was von Mathworks gefunden, dass kostet aber bestimmt wieder Geld.

Was das plotten der Funktionen angeht, werde ich wohl Python benutzen. 
Damit habe ich immer noch am meisten Erfahrung. Mathlab und Co. habe ich 
bis jetzt nur mit der Kneifzange 5 Minuten lang angefasst.
Muss ich mir allerdings unbedingt noch aneignen, da ich auf lange Sicht 
ja eh nicht daran vorbeikomme.

Zum Erstellen hochqualitativer Abbildungen von modulierten Signalen 
eignen sich Programme wie Asymptote
http://asymptote.sourceforge.net/gallery/

oder GLE
http://glx.sourceforge.net/

Willi Wacker schrieb:
> void main (void)
> {
>   while (1)
>   {
>     waitJahre (5);
>   }
> }

Ich bin kein Freund von "C", aber das ist mit Abstand der vernünftigste
Quelltext, den ich je sah.
:-))
MfG Paul

Beispiel für die Modulationsarten ASK,FSK und NRZ in Asymptote:

import graph;

size(16cm);

/**
 * @brief Erzeugt ein Feld mit Sinussignalen.
 * @param[in] N Anzahl an generierten Werten.
 * @param[in] A Amplitude des Sinussignals.
 * @param[in] fSin Frequenz des Sinus.
 * @param[in] fT Abtastfrequenz.
 * @return Feld mit den generierten Sinuswerten.
 */
real[] erzeugeSinus(int N, real A,real fSin, real fT)
{
  real result[]=new real[N];
  real Omega=2*pi*fSin/fT;
  real w=0.0;
  for(int index=0;index < N;++index)
  {
    result[index] = A*sin(w);
    w += Omega;
  }
  return result;
}


/**
 * @brief Moduliert die Bitdaten gemaess den Sendesignalen s0 und s1.
 * @param[in] bitdaten Feld mit 0- oder 1-Bits
 * @param[in] s0 Sendesignal für ein '0'-Bit.
 * @param[in] s0 Sendesignal für ein '1'-Bit - muss die gleiche Laenge 
wie s0 haben!
 * @return Feld mit dem Sendesignal
 */
real[] moduliereBinaer(int bitdaten[],real s0[], real s1[])
{
  int Nbit=bitdaten.length;
  int Ns=s0.length;
  int Nges=Nbit*Ns;
  real result[]=new real[Nges];
  int index=0;
  for(int bitIndex=0;bitIndex < Nbit;++bitIndex)
  {
    real s[]=(bitdaten[bitIndex]==0) ? s0 : s1;
    for(int sIndex=0;sIndex < Ns;++sIndex)
    {
      result[index]=s[sIndex];
      ++index;
    }
  }
  return result;
}


void zeichneSignal(real signal[],pair offset,string xlabel,string 
ylabel,real offs,real A,real xLength,pen achsenStift,pen graphenStift)
{
  int Ns=signal.length;
  pair xEnd=(xLength+offs,0);
  real yEnd=A+offs;
  real dX=xLength/Ns;
  real x[]=new real[Ns];
  real cx=0.0;
  for(int k=0;k<Ns;++k)
  {
    x[k]=cx;
    cx+=dX;
  }
  draw(shift(offset)*((0,0)--xEnd),achsenStift,Arrow(2));
  draw(shift(offset)*((0,-yEnd)--(0,yEnd)),achsenStift,Arrow(2));
  draw(shift(offset)*graph(x,signal),graphenStift);
  label(xlabel,offset+xEnd,SE);
  label(ylabel,offset+(0,yEnd),E);
}


real f0=110;
real f1=220;
real fT=8800;
int Ns=10*round(fT/f0);
real A=2cm;
real offset=1cm;
real yoffset=3.5*A;

real xLength=40cm;
pen graphenStift=linewidth(0.5mm);
pen achsenStift=linewidth(0.2mm);

int binaerSignal[]={1,0,0,1,0};

real s0NRZ[]=array(Ns,0.0);
real s1NRZ[]=array(Ns,A);
real s0ASK[]=s0NRZ;
real s1ASK[]=erzeugeSinus(Ns,A,f0,fT);
real s0FSK[]=s1ASK;
real s1FSK[]=erzeugeSinus(Ns,A,f1,fT);
real s0PSK[]=s1ASK;
real s1PSK[]=erzeugeSinus(Ns,-A,f0,fT);

real sNRZ[]=moduliereBinaer(binaerSignal,s0NRZ,s1NRZ);
real sASK[]=moduliereBinaer(binaerSignal,s0ASK,s1ASK);
real sFSK[]=moduliereBinaer(binaerSignal,s0FSK,s1FSK);
real sPSK[]=moduliereBinaer(binaerSignal,s0PSK,s1PSK);

zeichneSignal(sNRZ,(0,0),"$t$","$s_{NRZ}(t)$",offset,A,xLength,achsenSti 
ft,graphenStift);
zeichneSignal(sASK,(0,-yoffset),"$t$","$s_{ASK}(t)$",offset,A,xLength,ac 
hsenStift,graphenStift);
zeichneSignal(sFSK,(0,-2*yoffset),"$t$","$s_{FSK}(t)$",offset,A,xLength, 
achsenStift,graphenStift);
zeichneSignal(sPSK,(0,-3*yoffset),"$t$","$s_{PSK}(t)$",offset,A,xLength, 
achsenStift,graphenStift);

Nachtrag: Übersetzen mit asy -f pdf Modulation.asy

Kannst du das Ergebnisbild posten?

Kein Problem - habe die PDF-Datei mit dem Befehl
convert -density 200 Modulation.pdf Modulation.png
in eine PNG-Datei konvertiert, wobei die Rasterauflösung 200dpi beträgt.