QAM-Modulation, Eb/N0, SNR

Ok, ich will mal was präziser werden.
Das Bild im anhang ist das was ich programmiert habe, was auch 
funktioniert.

Gehen wir mal von einer PSK aus:
https://en.wikipedia.org/wiki/Phase-shift_keying

Also wenn ich ein Es (energy per symbol) von 1 habe, dann ist mein 
IQSignal laut wiki:

   S_IQ = sqrt(2*Es/Ts)*sin(w_c) + sqrt(2*Es/Ts)*cos(w_c)

Müsste es nicht sqrt(Es/Ts/2) sein, damit der Energiebetrag 1 ist?

Jedenfalls erzeuge ich mein rauschen mit:

   SNR = 10^(SNR_dB/10);   % SNR_dB gebe ich vor
   Eb = Es/2;              % Eb=Es/M QPSK => M=2
   N0=Eb/SNR;
   noiseSigma = sqrt(N0);
   noise = noiseSigma*randn(1,L);

Wie bereits geschrieben bekomme ich keine Übertragungsfehler und ich 
vermute, dass ich da irgendwas mit Eb, Es oder Ts vertauscht habe.
Bin jetz auch schon ne weile dran und seh den Wald nicht mehr.

Eine weitere Frage ist wie gesagt der Filter im Demodulator. Ich denke 
den muss ich nicht berücksichtigen, da ja das Rauschen in der 
Symbol/Bitbandbreite erhalten bleibt.
Allerdings ist es ja auch so, dass ich vor dem Filter die 
Trägerschwingung habe, welche nach dem Filter wieder das Bitmuster 
ergibt, allerdings um Faktor 2 gedämpft. Wie soll ich das für das Eb 
oder Es deuten?

Wäre nett wenn mir da jemand auf die Sprünge hilft.
Grüße

Gerade deswegen verwendet man ja die QAM, weil sie sehr fehlertolerant 
ist. Fehler bekommst du erst, wenn die vier Punkte sich zu Wolken 
aufgebläht haben und einander berühren. Die Rauschdichte deiner 
Noisequelle muss im Bereich um die Trägerfrequenz +- F mod größer sein 
als das Nutzsignal. Das klappt nur wenn die Symbolfrequenz größer Null 
ist. In der Praxis heißt das das deine Nachricht wenn die Symbolrate 
sehr klein ist auch bei großen Störpegeln empfangen werden kann.

um die Modulation selber geht es mir nicht.
Versuch nochmal mich etwas deutlicher auszudrücken:

ich habe eine IQ-Modulation, als Beispiel QPSK, wobei ich das Es und das 
Eb/N0 in db vorgebe. Ich muss also von Es auf i und q umrechnen (Bild 
1):

S_IQ Amplitude A   ( S_IQ = i*sin(w_c) + q*cos(w_t) )

   Es = A^2 * Tb   (Tb: Zeit eines Bits)
   A = sqrt(Es/Tb)

   A = sqrt(i^2+q^2)   , i=q   => A = sqrt(2) * i
   i = q = A/sqrt(2) = sqrt(Es/(2*Tb))

?Richtig?

Dann generiere ich das Rauschen mit der bereits gezeigten Routine.
Allerdings bekomme ich nur ein annähernd gutes Ergebnis wenn ich statt
Eb = Es/2  Eb=Es*2 nehme.
Siehe Bild 2 (blau: simuliert , rot: errechnet mit erfc)

Irgend was stimmt da doch nicht ganz oder?