Simulator für BER und modulierte Signale

[Alex W. (scipio)]

Hallo,

ich muss für meinen Studium eine Arbeit schreiben und würde da ganz 
gerne ein paar Bilder rein packen. Leider habe ich aktuell nichts auf 
dem Rechner, was mir entsprechende Diagramme und Graphiken erzeugen 
könnte.

Ich hab ein bisschen im Internet gesucht, jedoch nur kostenpflichtige 
Angebote gefunden. Ich könnte mir zwar über die Google Bildersuche was 
holen aber das ist sicher nicht das, was meine Betreuer gerne sehen 
würden.
Ich habe auch schon Wolfram Alpha abgeklappert, doch die können leider 
auch nicht das, was ich brauche.

Habt ihr noch ne Idee, wo man so einen Simulator finden kann?

MfG Scipio

[Timm T. (Gast)]

http://www.wolframalpha.com/input/?i=sin%28x%29*cos%28x%2F10%29

[Marek N. (Gast)]

Matlab bzw. Octave / Scilab.
Alternativ Python mit Numpy und Matplotlib.

Aber womit machts du denn dann die BER-Simulationen?

[Lord of L. (lightninglord)]

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

[Willi W. (williwacker)]

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

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

[Alex W. (scipio)]

@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.

[Rüdiger K. (sleipnir)]

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

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

[Paul B. (paul_baumann)]

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

[Rüdiger K. (sleipnir)]

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

[Rüdiger K. (sleipnir)]

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

[Abdul K. (ehydra)]

Kannst du das Ergebnisbild posten?

[Rüdiger K. (sleipnir)]

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.