C-Programm – doppelte Schleife

In diesem Beispiel zeige ich, wie sich eine doppelte Schleife auswirkt…

#include 

main() {
    /* Integer (ganze Zahl) */
    int x,y;

    /* die erste Schleife wird 10-mal durchlaufen */
    for(x=1; x< =10; x=x+1) {
        /* als erstes wird ein Zeillenumbruch (\n) dargestellt */
        printf("\n");

        /* die zweite Schleife befindet sich in der ersten,
           so dass diese jeweills 10*20-mal durchlaufen wird */
        for(y=1; y<=20; y=y+1) {
            /* Feldbreite von 4-Stellen (1234,  34,   4),
               nun wird 1*1, 1*2 [20-mal],
               dann     2*1, 2*2 [20-mal] gerechnet */
            printf("%4i", x*y);
        }
    }
}

/*
   1   2   3   4   5   6   7   8   9  10  11  12  13  14  15  16  17  18  19  20
   2   4   6   8  10  12  14  16  18  20  22  24  26  28  30  32  34  36  38  40
   3   6   9  12  15  18  21  24  27  30  33  36  39  42  45  48  51  54  57  60
   4   8  12  16  20  24  28  32  36  40  44  48  52  56  60  64  68  72  76  80
   5  10  15  20  25  30  35  40  45  50  55  60  65  70  75  80  85  90  95 100
   6  12  18  24  30  36  42  48  54  60  66  72  78  84  90  96 102 108 114 120
   7  14  21  28  35  42  49  56  63  70  77  84  91  98 105 112 119 126 133 140
   8  16  24  32  40  48  56  64  72  80  88  96 104 112 120 128 136 144 152 160
   9  18  27  36  45  54  63  72  81  90  99 108 117 126 135 144 153 162 171 180
  10  20  30  40  50  60  70  80  90 100 110 120 130 140 150 160 170 180 190 200
*/

C-Programm – Kommandozeilenparameter

In diesem Beispiel zeige ich, wie du Parameter in einem C-Programm einsetzen kannst…

/* 
read_args.c 

Achtung: 
        - bei Platzhaltern (*) !!! Wird hier noch nicht beruecksichtigt
        - die Hilfe ist nur per '-h' und nicht '--help' aufrufbar
        - Fehlermeldungen werden nicht ausgegeben
*/

#include <stdio.h>
#include <unistd.h>

int main(int argc, char *argv[]) {
        int option, i;
        char *out_filename=NULL;

        /* argc -> Anzahl Kommandozeilenparameter + Programmnamen (1), somit ist der Wert min. 1 */

        /* argv -> ist ein Zeiger auf das Feld (Array) mit der in argc angegebene Anzahl von Elementen...
                   ... und die Elemente (z.B.: argc[0] sind Zeiger auf eine Zeichenkette...

                   arg[0] -> Programmname
                   arg[1] -> 1. Parameter 
                   arg[2] -> 2. Parameter
                   [...]
                   arg[n] -> letzter Parameter
                    0L    -> das letzte Element von argv[] einthaelt eine Null
        */

        /* 
           getopt() sortiert zunaechst das Feld argc[] 
           1. Optionen
           2. Argumente

           Rueckgabewert: erste in der Kommandozeile angegebene Option oder -1 wenn keine Option angegeben wurde...
                          ... beim naechen Durchlauf jeweills die naechste angegebene Option...
                          ... und zum Schluss -1

           x:  -> 'x' waehre hier eine Option
           x:: -> 'x' waehre hier eine optinale Option
           xy: -> 'x' und 'y' waehren hier die Optionen (Optionsliste)  
        */
        while((option = getopt(argc, argv, "ho:")) >= 0) {
                switch(option) {
                        case 'h':
                                printf("Usage: %s [-o output-file] [input-file ...]\n", argv[0]);
                                return(0);
                        case 'o':
                                out_filename = optarg;
                                break;
                        /* wenn ein unzulaessige Option angegeben wurde, gibt getopt() ein '?' aus */
                        case '?':
                                return(1); /* unbekannte Option ... Abbruch */
                }
                /* die globale Variable 'optind' gibt den Index des ersten Arguments dem Feld argv[] weiter */
                for (i=optind; i<argc; i++) {
                        printf("'%s'\n", argv[i]);
                }
                if (out_filename) {
                        printf("output is '%s'\n", out_filename);
                }
        }
        return(0);
}

/*
Ausgabe:
./read_args -o test1 1 2 3 4 5 
'1'
'2'
'3'
'4'
'5'
output is 'test1'
*/

C-Programm – Primzahlen & Makefiles

Das folgende Programm gibt alle Primzahlen von 1 bis 100 aus, dabei wurde die Berechnung in eine eigene Funktion ausgelager.

/*
primzahlen.c
*/

#include <stdio.h>
#include <math.h>

/*
gcc -Wall -lm primzahlen.c -o primzahlen -O3
*/

int ist_primzahl(int zahl) {
    int teiler=2;

    /* solange der 'teiler' kleiner/gleich der (²)Wurzel aus 'zahl' ist ...
    ...  denn Primzahlen haben -keinen- Teiler der kleienr als dessen Quadratwurzel ist */
    while (teiler <= sqrt(zahl)) {
    /* alternativ, dann ohne <math.h> */
    /* while (teiler*teiler <= zahl) { */
        /* wenn kein Rest, dann... */
        if (zahl % teiler == 0) {
            /* ... 'false' */
            return(0);  /* 'zahl' ist keine Primzahl */
        }
        /* teiler und einen erhoehen */
        teiler++;
    }
    /* ... ansonsten 'true' */
    return(1);          /* 'zahl' ist eine Primzahl */
}

int main() {
    int zahl;

    /* solange bis 1 nicht mehr kleiner/gleich 100 bis, 1 erhoehen */
    for (zahl=1; zahl<=100; zahl++) {
        /* wenn Funktion='true' dann ...*/
        if (ist_primzahl(zahl)) {
            /* ... Zahl ausgebn */
            printf("%d\n", zahl);
        }
    }
    return(0);
}


Bei großen Projekten kann es hilfreich sein, diese Funktionen in verschiedenen Dateien zu organisieren und später wieder zusammen zu fügen…

1.) Den Quellcode in einen beliebigen ASCII-Texteditor eintippen und abspeichern.

2.) Den Quellcode mit einem Compiler übersetzen, wodurch eine Objektdatei (*.pbj oder *.o) erzeugt wird.

3.) Die Objektdatei mit einem Linker binden, so dass eine ausführbare Datei erzeugt wird. Der Linker sucht außerdem alle benötigten Funktionen aus den Standard-Bibliotheken heraus und fügt diese anschließend dem fertigen Programm hinzu.


zu 2.)

gcc -c primz_haupt.c
gcc -c primz_math.c

zu 3.)

gcc primz_haupt.o primz_math.o -lm -O3 -Wall -o primzahl


/*
primz_haupt.c
*/

#include <stdio.h>
#include "primz_math.h"

int main() {
        int zahl;

        for(zahl=1; zahl<=100; zahl++) {
                if (ist_primzahl(zahl)) {
                        printf("%d\n", zahl);
                }
        }
        return(0);
}
/*
primz_math.c
*/

#include <math.h>

int ist_primzahl(int zahl) {
        int teiler=2;

        while(teiler <= sqrt(zahl)) {
                if(zahl % teiler == 0) {
                        return(0);
                }
                teiler++;
        }
        return(1);
}


Um die zuvor beschriebene Prozedur zu beschleunigen, gibt es die sogenannten Makefiles, welche alle Informationen zum kompilieren enthalten und den Prozess somit automatisch durchführen können.

Als erstes ein ausführliches Beispiel:

# Makefile
#

#4.) 'primz_haupt.o' + 'primz_math.o' zusammenfuehren
primzahl:       primz_haupt.o primz_math.o
                gcc primz_haupt.o primz_math.o -lm -o primzahl

#3.) 'primz_haupt.o' erzeugen + 'primz_math.h' einfuegen
# Info: 'primz_math.h' ist die Verknuepfung zu 'primz_math.c'
primz_haupt.o:  primz_haupt.c primz_math.h
                gcc -c primz_haupt.c

#2.) 'primz_math.o' erzeugen
primz_math.o:   primz_haupt.c
                gcc -c primz_math.c

#1.) aufraeumen
clean: 
                rm -f primz_haupt.o prinz_math.o

Und hier die komprimierte Version: :-)

# Makefile2
#

TARGET  = primzahl
OBJECTS = primz_haupt.o primz_math.o
HEADERS = primz_math.h
LIBS    = -lm

$(TARGET):      $(OBJECTS)
                gcc $^ $(LIBS) -o $@

primz_%.o:      primz_%.c $(HEADERS)
                gcc -c $&lt; -o $@

clean: 
                rm -f $(OBJECTS)

C-Programm – Größe von Variablen

Mit diesem kleinem Programm kannst du dir die minimale und maximale Größe von Variablen ausgeben lassen. :-)

#include <stdio.h>
#include <limits.h>
#include <float.h>

int main(void) {
        printf("min. char-Wert          : %d\n", SCHAR_MIN);
        printf("max. char-Wert          : +%d\n", SCHAR_MAX);
        printf("min. unsigned-char      : 0\n");
        printf("max. unsigned-char      : %u\n\n", UCHAR_MAX);

        printf("min. short-Wert         : %d\n", SHRT_MIN);
        printf("max. short-Wert         : +%d\n", SHRT_MAX);
        printf("min. unsigned-short     : 0\n");
        printf("max. unsigned-short     : %u\n\n", USHRT_MAX);

        printf("min. int-Wert           : %d\n", INT_MIN);
        printf("max. int-Wert           : +%d\n", INT_MAX);
        printf("min. unsigned-int       : 0\n");
        printf("max. unsigned-int       : %u\n\n", UINT_MAX);

        printf("min. long-Wert          : %ld\n", LONG_MIN);
        printf("max. long-Wert          : +%ld\n", LONG_MAX);
        printf("min. unsigned-long      : 0\n");
        printf("max. unsigned-long      : %lu\n\n", ULONG_MAX);

        printf("min. long long-Wert     : %lld\n", LLONG_MIN);
        printf("max. long long-Wert     : +%lld\n", LLONG_MAX);
        printf("min. unsigned-llong     : 0\n");
        printf("max. unsigned-llong     : %llu\n\n", ULLONG_MAX);


        printf("min. float-Wert         : %f\n", FLT_MIN);
        printf("max. float-Wert         : +%f\n", FLT_MAX);
        printf("float Genauigkeit       : %d\n\n", FLT_DIG);

        printf("min. double-Wert        : %lf\n", DBL_MIN);
        printf("max. double-Wert        : +%lf\n", DBL_MAX);
        printf("double Genauigkeit      : %d\n\n", DBL_DIG);

        printf("min. long double        : %Lf\n", LDBL_MIN);
        printf("max. long double        : +%Lf\n", LDBL_MAX);
        printf("long double Genu.       : %d\n\n", LDBL_DIG);

        return 0;
}


Ausgabe:

min. char-Wert : -128
max. char-Wert : +127
min. unsigned-char : 0
max. unsigned-char : 255

min. short-Wert : -32768
max. short-Wert : +32767
min. unsigned-short : 0
max. unsigned-short : 65535

min. int-Wert : -2147483648
max. int-Wert : +2147483647
min. unsigned-int : 0
max. unsigned-int : 4294967295

min. long-Wert : -2147483648
max. long-Wert : +2147483647
min. unsigned-long : 0
max. unsigned-long : 4294967295

min. long long-Wert : -9223372036854775808
max. long long-Wert : +9223372036854775807
min. unsigned-llong : 0
max. unsigned-llong : 18446744073709551615

min. float-Wert : 0.000000
max. float-Wert : +340282346638528859811704183484516925440.000000
float Genauigkeit : 6

min. double-Wert : 0.000000
max. double-Wert : +179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889[…]

min. long double : 0.000000
max. long double : +1189731495357231765021263853030970205169063322294624200440323733891737005522970722616410290336528882853545697807495577314427443153670[…]


Wenn du das nächste C-Programm einmal kompiliert hast und es mehrere male nacheinander ausführst siehst du, dass die Variable ggf. an einer anderen Stelle im Speicher abgelegt wurde.

#include <stdio.h>

int main(void) {
        int var=0;
        printf("Die Adresse von var lautet: %p\n", &var);
        return 0;
}

C-Programm – letzte Ziffer anzeigen

Die letzte Ziffer einer Zahl ausgeben lassen…

#include <stdio.h>

void main(void) {
    int n,letzteZiffer;

    /* 
       
      n mod 10 
    = n % 10 
    = Rest, nach der Division durch 10
     
    "Die Division mit Rest (Modulo) wird in der Programmierung relativ häufig verwendet. 
    Die Syntax ist dabei die eines Operators. Mit mod kann geprüft werden, 
    ob eine Zahl gerade ist: if ( (x mod 2) == 0), dann ist x gerade. 
    Modulo kann man immer benutzen, wenn man alle X Schleifendurchläufe einen speziellen 
    Programmcode ausführen will. Auch bei vielen Berechnungen und Algorithmen ist er 
    sinnvoll einsetzbar. Allgemein kann man mit mod prüfen, 
    ob eine Zahl durch eine andere genau teilbar ist, dann ist der Modulo nämlich Null." - wiki

    */

    printf("Bitte eine Zahl eingeben: ");
    scanf("%d", &n);
    letzteZiffer = n % 10;
    printf("\nletzteZahl %d\n", letzteZiffer);
}

Wie interpretiert man DSL-Informationen

“Mit Asymmetric Digital Subscriber Line (ADSL, engl. „asymmetrischer, digitaler Teilnehmer-Anschluss“) wird die zur Zeit häufigste Anschlusstechnik von Breitbandanschlüssen für Konsumenten bezeichnet. Sie wurde auf Basis der DSL-Technik mit der Maßgabe entwickelt, über die vorhandene Telefonanschlussleitung zu funktionieren, ohne die Telefonie über den Festnetzanschluss zu beeinträchtigen, und gleichzeitig den meist asymmetrischen (ungleichen) Datenratenbedürfnissen der Privatkunden nach höherer Empfangs- als Sendedatenrate nachzukommen.” – wiki


ADSL ist im Gegensatz zu SDSL weiter verbreitet und um einiges günstiger, da man zwar hohe Downloadraten, jedoch nicht so hohe Uploadraten erzielt. Das Übertragungsverfahren für ADSL wird über die bestehende Telefonverkabelung realisiert, es handelt sich um ein asymmetrisches breitbandiges Datenübertagungsverfahren (SDSL = symmetrische), welches auf die herkömmliche Kupfer-Doppelader im Anschlussbereich geschaltet wird. Zur ADSL-Kommunikation muss auf beiden Seiten der Anschlussleitung ein ADSL-Modem installiert sein, sowohl in der Ortsvermittlungsstelle als auch beim Teilnehmer, daher hängt die max. Geschwindigkeit der Leitung auch maßgeblich von der Entfernung zur Hauptvermittlungsstelle (HVT) und die Qualität (dicke) des eingesetzten Kabels ab. Hier noch schnell ein Link, wo du die Vermittlungsstellen finden kannst -> “www.schmalbandatlas.de/atlas/“. Wenn du nun einige Kilometer von solche einer Stelle entfernt wohnst, ist dies noch nicht weiter schlimm, da du wahrscheinlich über einen von zirka 300.000 Kabelverzweigeren (KVZ) mit dem HVT verbunden bist.


ADSL-Datenraten


DSL-Leitungs-Informationen kann man in jedem handelsüblichen DSL-Modem finden, diese Werte können nützliche sein um z.B. Probleme von ADSL einzugrenzen oder Leitungsfehler festzustellen. Die Werte können außerdem als grober Richtwert dafür verwendet werden, ob eine Leitung mit höheren Geschwindigkeiten laufen könnte oder eben nicht!


Welche Zahlen musst du dir anschauen?

Verschiedene Router bezeichnen diese Zahlen unterschiedlich, aber die wichtigsten Werte (Zahlen), sollten in etwa folgende Bezeichnung haben: (ADSL-Status / Statusübersicht)
  • Connection-, Sync-Speed oder Rate
  • Attenuation / Dämpfung oder Atten oder Loop loss
  • SNR Margin oder Noise Margin oder Noise oder Margin
  • Einzelheiten über etwaige CRC / HEC / RS / FEC Fehler und fehlerbehaftete Sekunden können ebenfalls hilfreich sein.




Es gibt natürlich auch Router / Modems welche noch weitere Zahlen & Fakten welche eventuell helfen können die Leitung zu analysieren, anzeigen. Jedoch sollten die meisten Geräte die soeben genannten Dinge anzeigen können.


Was ist “Sync Speed”?

Die Geschwindigkeit, mit der der Router synchronisiert (verbindet), dies wird vom Provider entweder “fest” eingetragen oder wird “dynamisch” mit der Gegenstelle ausgehandelt, so dass deine Leitung ggf. mit weniger Bandbreite synchronisiert, wenn z.B. die Qualität der Leitung schlechter wird. (die Leitung kann z.B. schlechter werden, wenn plötzlich alle deine Nachbarn einen DSL-Anschluss haben und somit sich diese Leitungen in der Vermittlungsstelle gegenseitig stören.

Daher ist es auch nicht ungewöhnlich, wenn du nach einem Reboot deines Routers eine andere Geschwindigkeit angezeigt bekommst.


Es ist wichtig zu bedenken, dass der “Sync Speed” nicht deine “wahre Geschwindigkeit” ist, mit welcher du downloaden kannst. Solche Dinge wie der “TCP/IP Overhead” führen dazu, dass eine Leitung welche mit z.B. 8128 kbps synchronisiert ist, einen maximalen Durchsatz-Geschwindigkeit von rund 7,1 MB hat (ca. 13% weniger).


Was ist Dämpfung?

Leitungsdämpfung steht im Zusammenhang mit “loop lose”, je niedriger dieser Wert ist desto besser und desto bessere sind deine Chancen immer eine hohe Geschwindigkeiten zu haben.


Der Begriff Dämpfung wird verwendet, um die Reduktion der ADSL-Signalstärke, die auf dem Kupferkabel über größere Entfernungen auftritt zu beschreiben. Die Dämpfung wird in dB (Dezibel) gemessen und je weiter du vom der Vermittlungsstelle entfernt bist, desto höher steigen die Dämpfungswerte  bzw. mit desto mehr Signal-Verluste treten auf.

Dämpfung ist exponentiell, somit halbiert jeweils  3dB Dämpfung die Stärke des Signals. Erhält man daher mit 30dB Dämpfung nur 1/1.000 der Signalstärke, so erhält man mit 60dB nur noch 1/1.000.000 der Signalstärke.


Die wahre Leitungsdämpfung kann nur am DSLAM, in der Vermittlungsstelle gemessen werden (DSLAM = DSL Adress Multiplexer) – hier werden die Daten vieler DSL Nutzer (Adressaten) zusammenfasst (Multiplex) und in das schnelle ATM Netz einspeist) Jedoch kann unser Router uns bereits einen Richtwert anzeigen.

Wenn man höhere Frequenzen / Geschwindigkeiten auf einer Leitung fährt (500kb zu 2Mb) ist es sehr wahrscheinlich, dass die Dämpfungswerte nach oben gehen, da höhere Frequenzen, wie sie verwendet werden, um höhere Geschwindigkeiten zu übertragen eher gedämpft werden (höhere Frequenzen = höhere Dämpfung).

ADSL2+ hat eine erhöhte Frequenz-Spektrum, also eine erhöhte Dämpfung von ca. 3-4dB. Als sehr grobe Orientierung:

Eine Geschwindigkeitssteigerung von 4MB bewirkt  ~1dB Erhöhung der Dämpfung.

Da unterschiedliche Router verschieden mit den Frequenzen zurechtkommen, kann es sein, dass  Router nicht auf 1Mb bei einer weiten Entfernung zur Vermittlungsstelle synchronisieren andere Modelle hingegen schon. Sehr gute Erfahrungen hab ich hier mit SpeedTouch-Geräten gemacht. :-)


Was ist SNR?

SNR Signal to Noise Ratio – in anderen Worten: eine Messung in Dezibel der Signalstärke auf der Leitung. Um die Information sicher aus dem Signal extrahieren zu können, muss sich das Nutzsignal deutlich vom Hintergrundrauschen abheben, das SNR muss also ausreichend groß sein. Fällt das SNR, steigt die Fehlerrate. Dem SNR entspricht bei der Digitalübertragung die Bitfehlerrate und je höher dein  SNR-Wert ist, desto besser, da es weniger Nebengeräusche gibt. :-)


SNR schwankt auf allen Leitungen im Laufe des Tages durch verschiedene Faktoren. Die Signalstärke ist in der Regel am Morgen besser als am Abend, da am Abende mehr “Lärm” auftritt, da mehr Menschen zu Hause sind und somit elektromagnetisches Rauschen verursachen. Die Liste der Stör-Quellen ist lang… es können Fernseher, PCs, Beleuchtung, Heizung, Pumpen etc. sein.



Eine einfache bildliche Beschreibung von SNR:

SNR
  • “Du” bist der DSLAM in der Vermittlungsstelle (links)
  • “Ihre Stimme” ist das DSL-Signal. (blaue Linie)
  • “Dein Freund” ist der Router bei dir @ home (rechts)
  • Die “Musik” sind generelle Hintergrundgeräusche aus verschiedenen elektromagnetischen Quellen (unten)
  • Die “andern Gespräch” sind alle anderen DSL-Anschlüsse in deiner Nähe (oben)

Dein Freund kann dich besser verstehen, wenn du näher bei Ihm bist, als wenn er auf der anderen Seite des Raumes ist, dies entspricht dem Abstand zwischen deiner Wohnung und der Vermittlungsstelle – je weiter man von der Vermittlungsstelle weg wohnen, desto schlechter die Signale und so anfälliger ist die Leitung für Störsignale (Lärm).

Jede Leitung muss eine bestimmte Menge an SNR haben, um bei einer bestimmten Geschwindigkeit zu funktionieren. Sehr grob kann man sagen, dass 1dB (SNR) entspricht 450 kbps der Geschwindigkeit, aber auch andere Faktoren wie die Dämpfung und Leistung müssen im Auge behalten werden.


Was ist SNR Margin?

SNR Margin resultiert aus SNR, ist aber nicht das Gleiche. SNR Margin könnte als “Pufferzone” bezeichnet werden, die es gibt, um Verbindung gegen normale SNR-Schwankungen, welche täglich auftauchen zu schützen.

Die meistern Standard-Router zeigen in der Regel die “SNR Margin” und nicht der “SNR-Wert” an, unabhängig von der angezeigten Bezeichnung. Je nach Hersteller kann dies “Receive Margin”, “SNR”, “Noise” oder jede Variation davon sein oder es kann auch zu SNRM oder Noise Margin abgekürzt werden.

SNR Margin ist die Differenz zwischen dem tatsächlichen und dem SNR und dem benötigtem SNR, um bei einer bestimmten Geschwindigkeit stabil zu laufen. Zum Beispiel, wenn Ihre Leitung 35dB SNR haben muss, um auf 8Mbps zu laufen, und die aktuelle Leitung einen SNR von 41dB hat, dann ist die SNR Margin 6dB.

Wenn somit dein “SNR Margin”-Wert zu niedrig ist, kann die Leitung zusammen brechen, welche auch zwischen-zeitig auftreten können, somit ist ein Blick auf deinen “SNR Margin”-Wert oft eine nützliches Mittel ADSL-Fehler festzustellen. Dämpfung und SNR Margin sind unabhängige voneinander, so kannst du eine gute Dämpfung haben, aber einen schlechten (niedrigen) SNRM – oder umgekehrt.


Was ist Target SNR Margin?

Wenn der Sync-Speed automatisch ausgehandelt wird, muss man jedoch noch einen gewissen Rahmen angeben, so teilt man seinem Modem mit, dass man einen Target SNR Margin von z.B. 10dB wünscht und es die Verbindung so herstellen soll. (Dies kann jedoch auch nicht bei allen Routern angegeben werden.) Wenn du z.B. eine Fritzbox im Einsatz hast und Verbindungsabbrüche feststellst, dir dann deine “SNR Margin” anschaust und diese sehr niedrig ist, solltest du einmal ein anderes Gerät an deinem Anschluss ausprobieren, da die Fritzbox besonders schnelle Verbindungen aufzubauen versucht und den “Target SNR Margin”-Wert zu niedrig ansetze. Warum AVM das macht? Es könnte daran liegen, dass man anderen (besseren) Modems in punkto Geschwindigkeit nicht nachstehen möchte.

Somit spielt die Target SNR Margin eine wichtige Rolle bei der Synchronisierung zwischen deinem Router und dem DSLAM in der Vermittlungsstelle. Target SNRM beeinflusst die Geschwindigkeit, mit der wir Synchronisieren und legt die anfängliche SNR Margin (Pufferzone) fest und ist somit die  (grobe) Voreinstellung der SNR Margin unmittelbar nach einer Resynchronisation.


Meist werden 6dB, 9dB, 12dB oder 15dB als Profile verwendet, wobei 6dB der Standardwert ist. Längere Strecken sind anfälliger für Störungen (Lärm) und benötigen daher oft eine höheren Wert als kürzere Leitungen.

Es ist wichtig zu beachten, dass auf sehr guten Leitungen, die in der Lage sind mit über 8 MB zu synchronisieren und die derzeit mit 8128 oder 7616 Synchronisiert sind, der SNR Margin-Wert als höher eingestuft ist, da die “output power” ggf. reduziert wurde, um Störungen von anderen Leitungen zu minimieren und somit wäre der SNRM-Wert “verfälscht”.


Wie schnell sollte meine Verbindung sein?

Dies hängt ganz von der Entfernung von der Vermittlungsstelle und den Zustand Ihrer Telefonleitung ab.

Du kannst einen groben Wert aus deiner Leitungsdämpfung und deiner Leitungslänge berechnen lassen, jedoch spielen hier noch Unmengen andere Stör-Quellen eine Rolle, wodurch deine Geschwindigkeit in der Realität stark von deinem Ergebnis abweichen kann.

-> www.kitz.co.uk/adsl/max_speed_calc.php


Was sind BT Fixed Rate Grenzen?

Idealerweise sollte deine Leitungslänge unterhalb von 3,5 km sein, um eine 2Mb Verbindung zu bekommen und 6km, für eine 1Mb Verbindung nicht überschreiten.

Auf einigen Leitungen kann man ein festes Profil einstellen, dies kann hilfreich sein, wenn man z.B. große Schwankungen von SNR hat, welche in guten Zeiten mit hohen Geschwindigkeiten synchronisieren und dann öfter zusammenbrechen.


Dämpfung Geschwindigkeit Sync
Down
Sync
Up
Profil
> 60dB 512 kbps 576 64-288

Profil 500

43 bis 60 dB 1 Mbps 1152 288 Profil 1000
<= 42 dB 2 Mbps 2272 288 Profil 2000


63.5 dB Dämpfung?

Der Grund dafür, dass einige Router / Modems eine maximale Dämpfung  von 63.5 dB anzeigen, ist das im G.992.1-Standard folgendes steht, -> “Die Dämpfung reicht von 0 bis 63,5 dB mit 0,5 dB-Schritten.” Daher  haben viele Firmware-Versionen diese als Grundlage und sind daher buchstäblich nur bis 63.5dB ausgelegt. Wenn dein Router 63.5dB anzeigt, dann kann es sein, dass die Dämpfung in Wirklichkeit höher ist.


Quelle:

http://www.kitz.co.uk/adsl/linestats.htm