Rechteckgenerator mit Atmega8 nicht so einfach (Anfänger)

[Marko E. (marko_e)]

Hallo zusammen

Ich habe versucht mit einem Atmega 8 einen Rechteck Generator zu 
programmieren (als Anfänger).

Die Tutorials mit delay bringen zwar eine LED zum blinken, helfen aber 
nicht wirklich weiter.

Dann habe ich es über Timer versucht, vielversprechend.

Ich habe mittlerweile aber schon 230 Codezeilen für einen 
Rechteckgenerator  in C geschrieben. Das kann es doch nicht sein.

Vermutlich denke ich einfach falsch.

Mega8 = 6 MHZ
fout = 0,01 - 350 Khz

Es giebt im Internet genau so etwas als .asm und als .hex.
nutzt mir aber nichts weil ich es nicht verstehe.

eventuell weiss ja einer wo man sich mal ein c (Ablauf)Programm ansehen 
kann.

Marko

[Norbert S. (norberts)]

Hi,

"Wo gibt es ein Beispiel" ist als Frage vermutlich nicht so zielführend.

Schreib doch wo die Probleme sind, wie Dein Konzept ist usw.
Vielleicht erstmal mit einer einfacheren Version, feste Frequenz z.B..
Dann sieht man sich Deinen Code hier sicherlich auch durch und sagt Dir, 
wo das daneben ist (oder auch nicht).

Gruß,
Norbert

[R. R. (elec-lisper)]

Wo ist denn der Code, den wir uns anschauen sollen? Bitte auch einen 
Schaltplan. Ein Rechecksignal sollte sich via PWM in relativ wenig 
Codezeilen bauen lassen. Aber für ne variable Frequenz klingen 230 
Zeilen noch nicht besorgniserregend.

[Marko E. (marko_e)]

Hallo Norbert

Konzept ist ja erstmal Rechtekgenerator programmieren.
Eckdaten:

fout = 0,01 - 350 Khz

Mein Problem ist ja nicht das ich es nicht hinkriege nur meine 230 
codezeilen scheinen mir etwas viel. Wenn man googelt giebt es ein 
Beispiel in asm welches ich aber nicht verstehe, daher meine frage nach 
einem Beispiel in C. Das verstehe ich besser.

Marko

Ich hänge mal meine C-Datei an. Aber erschlage mich bitte nicht.

Ich bin Anfänger.

Marko

[M. K. (sylaina)]

Habe deinen Code grade nur überflogen. 230 Zeilen sind nicht viel dafür, 
du machst ja auch noch eine LCD-Anzeige dafür, da kannst du bei deinem 
Beispiel bestimmt 10% der Zeilen schon mal abziehen, sind doch locker 20 
LCD-Funktionen die du da aufrufst.
Dann fiel mir noch was auf: Überlege dir mal was du auf dem LCD anzeigen 
willst. Wenn du zum Beispiel immer in Zeile 2 zu Beginn ein "f: " stehen 
hast kannst du das auch in die LCD-Initialisierung packen und es kann 
aus jeder if-Anweisung rausfliegen oder anders gefragt: Warum schreibst 
du y ins Display an die Stelle x an der y schon steht? ;)

[Matthias S. (Firma: matzetronics) (mschoeldgen)]

Marko E. schrieb:
> daher meine frage nach
> einem Beispiel in C. Das verstehe ich besser.

Da ist nichts dran ehrenrührig. Anbei mal mein Rechteckgenerator in C, 
diesmal mit Mega 8515. Der Name 'Konstanz' kommt von der Beschriftung 
der ehemaligen (MCS-51) Hardware - war ein Zeitnehmer aus dem 
Lehrmittelbetrieb mit grossem 2*20 Zeichen LCD. Und 'ne Uhr ist mit 
drin, die ich hauptsächlich zum Abgleich des Quarzes benutzt habe.

[Karl H. (kbuchegg)]

Marko E. schrieb:

> Ich hänge mal meine C-Datei an. Aber erschlage mich bitte nicht.

Ist nicht weiter schlimm.

Zu dem was Michael Köhler angeführt hat, möchte ich noch eine Sache 
ergänzen, die wichtig ist.

In deinem Code gibt es immer wieder mehr oder weniger gleiche Sequenzen, 
die ganz spezifische Aufgabenstellungen lösen. Zum Beispiel hier

....
        ultoa(f, Buffer, 10);
        lcd_setcursor( 0, 1 );
        lcd_string("f: ");
        lcd_string(Buffer);
....

das kommt immer wieder mehr oder weniger genau gleich. Die angestrebte 
Funktionalität lässt sich aber ganz leicht zusammenfassen. Du willst 
hier an eine bestimmten POsition am LCD einen Zahlenwert (als unsigned 
long) ausgeben, wobei du noch eine Beschriftung davor stellen willst.
Das ist gut so und auch legitim.
Was aber nicht gut ist, das ist das du dieselbe Funktionalität immer 
wieder ausprogrammierst. Genau an dieser Stelle kommen Funktionen ins 
Spiel. Spätestens dann, wenn die gleiche Funktionalität nur mit anderen 
Zahlen und/oder Variablen immer wieder auftaucht, spätestens dann ist es 
Zeit dafür eine Funktion zu schreiben. In deinem Beispiel ganz einfach

void lcd_label_uint32( uint8_t zeile, uint8_t spalte, const char* label, uint32_t value )
{
  char buffer[20];

  ultoa( value, buffer, 10 );

  lcd_setcursor( zeile, spalte );
  lcd_string( label );
  lcd_string( Buffer );
}

auch kommt zum Beispiel die Ausgabe eines unsigned int in deinem Code 
ein paar mal vor. Warum nicht auch dafür eine eigene Funktion machen?

void lcd_uint16( uint8_t zeile uint8_t spalte, uint16_t value )
{
  char buffer[7];

  utoa( value, buffer, 10 );

  lcd_setcursor( zeile, spalte );
  lcd_string( Buffer );
}

und anstelle dem immer gleichen Einzelablauf in der main, schreibst du 
dann ganz einfach beispielsweise

....
   if( get_key_press( 1<<KEY1 ) || get_key_rpt( 1<<KEY1))  // Taster 1 freq 1Hz höher
      {
        PORTC ^= (1<<PC5);

        lcd_clear();
        lcd_setcursor( 0, 0 );
        lcd_string("Taste 2 repeat");

        f++;
        lcd_label_uint32( 0, 1, "f:", f );

        i = (F_CPU/(Prescaler8 * f))-1;    // Zählervorladewert berechnen
        lcd_uint16( 10, 1, i );

        OCR1A = i;
      }

Das verkürzt nicht nur den Code, es hilft dir auch, dich hier im main 
auf das wesentliche zu konzentrieren. Denn wesentlich hier ist ja wie 
sich die Frequenz verändert und welcher OCR Wert sich daraus ergibt. Das 
ist das, was du hier sehen möchtest und was hier wichtig ist. Die 
Details der Ausgabe sind hier recht unwichtig, die willst du an dieser 
Stelle aus dem Code raushaben. Wenn sie dich interessieren, dann kannst 
du immer noch in der Funktion nachsehen. Aber erstmal gibst du dich an 
dieser Stelle im Code damit zufrieden, dass ein lcd_label_uint32 dir 
einen 32 Bit Wert mit Beschriftung an eine bestimmte Stelle am LCD malt. 
Mehr musst du hier an dieser Stelle nicht wissen, weil es hier nicht 
wesentlich ist, wie das passiert. Wenn doch -> in der Funktion 
nachsehen.

Man könnte hier ja auch noch weiter gehen.
Denn wenn eine Frequenz erhöht wird oder wenn sie erniedrigt wird, dann 
ist das ja immer der gleiche Ablauf. Warum soll sich das dann nicht zb 
so schreiben

   if( get_key_press( 1<<KEY0 ) || get_key_rpt( 1<<KEY0))  // Taster 0 freq 1 Hz niedriger
      {
        f--;
        setNewFrequency( f );
      }

   if( get_key_press( 1<<KEY1 ) || get_key_rpt( 1<<KEY1))  // Taster 1 freq 1Hz höher
      {
        f++;
        setNewFrequency( f );
      }

   if( get_key_press( 1<<KEY3 ) || get_key_rpt( 1<<KEY3))  // Taster 3 freq 100 Hz niedriger
      {
        f=f-100;
        setNewFrequency( f );
      }

   if( get_key_press( 1<<KEY4 ) || get_key_rpt( 1<<KEY4))  // Taster 3 freq 100 Hz höher
      {
        f=f+100;
        setNewFrequency( f );
      }

Merkst du was?
Deine ganzen Kommentare sind plötzlich eigentlich überflüssig. Denn das 
hier zum Beispiel die Taste 1 gedrückt wurde, das sehe ich auch im Code. 
Der Begriff 'KEY1' kommt da ja an der betreffenden Stelle recht 
prominent vor. (Und das einer deiner Kommentare eigentlich falsch ist, 
das ist jetzt auch deutlich ersichtlich. Denn im letzten Fall ist es die 
Taste 4 und nicht die Taste 3. Falsche Kommentare sind noch schlimmer 
als keine Kommentare)
Und das hier die Aktion darin besteht, dass die Frequenz um 1Hz erhöht 
wird, auch das kann ich dort leicht ablesen. Genau das ist ja die 
Bedeutung von

       f++;

Wenn du die Variable nicht f sondern zb 'frequency' gennant hättest, 
dann würde da beispielsweise (an anderer Stelle) stehen

       frequency = frequency + 100;

und das ist nun wirklich schon fast ein vollständiger, komplett 
verständlicher Satz. Denk dir die Sonderzeichen durch Wörter ersetzt, 
dann steht da praktisch im Klartext "Die Frequenz wird erhöht, indem 100 
zur Frequenz dazugezählt werden". Da braucht es keinen Kommentar mehr, 
der mir genau dasselbe im deutschen Satz sagt. Die Anweisung im Code 
spricht für sich selbst. Im Deutschen würde man vielleicht kürzer sagen 
"Die Frequenz wird um 100 erhöht", die C Schreibweise dafür wäre

      frequency += 100;

Als Nebeneffekt der Funktionen hast du 3 Seiten Code auf eine halbe 
Seite + die Funktionen eingedampft. Was dann auch noch den Nebeneffekt 
hat, dass du, sollte sich die Berechnung der kritischen Werte abhängig 
von der Frequenz einmal ändern, oder sich an der Anzeige etwas ändern, 
dies nur an einer einzigen Stelle tun musst. Nämlich hier

void setNewFrequency( uint32_t frequ )
{
  PORTC ^= (1<<PC5);

  lcd_clear();

  lcd_label_uint32( 0, 1, "f:", frequ );

  i = (F_CPU/(Prescaler8 * frequ))-1;    // Zählervorladewert berechnen
  lcd_uint16( 10, 1, i );

  OCR1A = i;
}

Kurz und gut: Funktionen sind eine deiner Waffen, wie du Code 
vereinheitlichen, verkürzen, übersichtlicher und gleichzeitig leichter 
wartbar (veränderbar) machen kannst.
Die gesparte Zeit investierst du lieber darin, deinen Code leicht lesbar 
zu machen. Es gibt keinen Grund alle Zeichen knirsch an knirsch 
aneinander zu kleben. Seit du 6 Jahre alt bist, hast du dein Gehirn 
darauf trainiert, dass zwischen einzelnen Wörtern in einem Text ein 
Leerraum steht. Dein Gehirn hat das gelernt und ermöglicht dir so 
leichteres Lesen, weil du nicht erst umständlich die Wörter 
identifiziern musst. Ein

     f = f + 100;

ist für dein Gehirn mit viel weniger Anstrengung zu lesen, als ein

     f=f+100;

> Ich bin Anfänger.

Das wird schon. Es ist noch kein Meister vom Himmel gefallen. Programme 
zu strukturieren will auch gelernt sein.

[Marko E. (marko_e)]

Hallo Karl

Von Deiner Antwort bin ich überwältigt.
Da möchte ich hin.

Das es mit Funktionen besser gehen sollte habe ich bemerkt. Aber leider 
nicht hin bekommen.

Dein erstes Beispiel hat mir sehr geholfen. Ich hatte es auch schon in 
der Art versucht aber es gab immer Probleme mit Datentypen. const char* 
ist mir neu, funktioniert aber.

Jetzt muss ich erstmal DoKu lesen.

Herzlichen Dank für Deine ausfürliche Beschreibung.

PS
Den Rest Deiner Beschreibung versuche ich natürlich auch noch 
umzusetzen.
Dauert aber etwas.

Marko

[Marko E. (marko_e)]

Auch Dank an Matthias Sch.

für das Beispielrogramm.
Leider vertehe ich nicht so viel. Wird sich aber ändern.

Marko

[M. K. (sylaina)]

Karl H. schrieb:
> lcd_setcursor( zeile, spalte );

Psst, das ist umgedreht, erst die Spalte, dann die Zeile ;)

[chris_ (Gast)]

>void setNewFrequency( uint32_t frequ )

Noch eine kleine Anmerkung zur Dokumentation von Funktionsparametern. 
Hier kann es nützlich sein, wenn man in den Parameternamen gleich die 
Einheit mit hinein packt.

z.B.
void setNewFrequency( uint32_t f_Hz )
void setNewFrequency( uint32_t f_kHz )
void setNewFrequency( uint32_t f_MHz )

[Matthias S. (Firma: matzetronics) (mschoeldgen)]

Marko E. schrieb:
> Leider vertehe ich nicht so viel. Wird sich aber ändern.

Da bin ich sicher. Verwirrend ist vermutlich, das da noch ein STDIN und 
STDOUT auf der UART initialisiert wird (siehe das Tutorial des 'grossen' 
Beispiels in der avr-lib) und das da eben noch eine Uhr mitläuft.
Timer 0 macht die Uhr, Timer 1 ist der Rechteckgenerator (mit CTC wie 
bei dir). Ich schalte abhängig vom Bereich den Prescaler mit um und 
benutze das EEPROM, um den gewünschten Einschaltzustand zu speichern.

Peter Fleurys LCD Lib fehlt im Download, aber die gibts im Internet.
Die Uhr habe ich dazu benutzt, um mittels Trimm-C den Quarzoszillator 
möglichst genau hinzuziehen. Dazu habe ich einmal am Tag die Abweichung 
gemessen und mit dem Trimmer nachgezogen.

[LostInMusic (Gast)]

>f = f - 100;
>setNewFrequency( f );

Mir drängt sich da eine Frage auf: Es mögen gerade 5 Hz erzeugt werden 
und dann drückt jemand auf die "100 Hz weniger"-Taste. ...?

>void setNewFrequency( uint32_t f_MHz )

Ob sich das bei der Handvoll MHz-Frequenzen, die der µC bei FOSC = 6 MHz 
erzeugen kann (nämlich 1, 1.2, 1.5, 2 und 3 MHz), lohnt?

Ich halte es für klug, das mit dem "setNewFrequency" überhaupt mal 
generell zu überdenken. Weil man OCR-Register nur auf ganzzahlige Werte 
setzen kann.

[M. K. (sylaina)]

LostInMusic schrieb:
> Ob sich das bei der Handvoll MHz-Frequenzen, die der µC bei FOSC = 6 MHz
> erzeugen kann (nämlich 1, 1.2, 1.5, 2 und 3 MHz), lohnt?

Das war von Chris nur als Beispiel gedacht. Es geht halt darum, dass man 
generell dem Parameter einen Namen geben sollte, der seine Funktion 
beschreibt.

[Peter D. (peda)]

LostInMusic schrieb:
> Mir drängt sich da eine Frage auf: Es mögen gerade 5 Hz erzeugt werden
> und dann drückt jemand auf die "100 Hz weniger"-Taste. ...?

Ich würde daher einen Bereichstest mit in die Funktion aufnehmen:

changeFrequency( -100 );

[Marko E. (marko_e)]

Nochmals vielen Dank für alle Antworten.
Es ist aber im Moment etwas viel. Ich muss die Antworten ja auch erst 
einmal verstehen. Kann ich nicht so schnell.

Karl Heinz hat wunderbare Anregungen gegeben. Die muss ich mir aber 
erstmal alle einverleiben.

@ LostInMusic
Das man das OCR nur auf ganzzahlige Werte setzen kann war mir klar, ich 
hatte aber beim programmieren nicht daran gedacht das es ab 3 Khz 
Probleme macht. Ich möchte das Konzept aber dennoch verfolgen da ich im 
Moment eine Menge lerne.
Vermutlich kann man die eigentliche Signalerzeugung ja später noch 
ändern.

@peda
Bereichsumschaltung habe ich versucht aber diese Beschränkung vom OCR 
auf 16 bit bleibt ja. Wie bekomme ich eine Auflösung von 1 Hz hin?

Ich versuche jetzt erst einmal alle Eure Anregungen zu verstehen.

Vielen Dank.

PS: Ich hätte nicht gedacht dass es so schwierig ist einen 
Rechteckgenerator zu programmieren.

Marko

[M. K. (sylaina)]

Marko E. schrieb:
> Wie bekomme ich eine Auflösung von 1 Hz hin?

Gar nicht. Zumindest nicht über den kompletten Bereich. Im unteren 
Bereich kann es aber schon klappen, dafür musst du dann nicht nur das 
OCR anfassen sondern auch den Clock-Prescaler des zugehörigen Timers 
ändern.

[LostInMusic (Gast)]

>Ich hätte nicht gedacht dass es so schwierig ist einen
>Rechteckgenerator zu programmieren.

:-) Der Hund liegt hier begraben: Man darf nicht aufgrund der 
(zutreffenden) Tatsache, viele Frequenzen erzeugen zu können, annehmen, 
praktisch beliebige Frequenzen nach freier Wahl erzeugen zu können. Das 
wäre ein Fehlschluss! Tatsächlich liegen prinzipbedingt sehr, sehr viele 
der erzeugbaren Frequenzen im unteren Bereich und haben grauenhaft 
krumme Werte (z. B. 131.0587362 Hz oder 131.061599 Hz). All diese 
Frequenzen sind für Dich wahrscheinlich nicht attraktiv. Ich vermute 
mal, Dein Generator soll überhaupt nur ganzzahlige Frequenzen 
erzeugen? Allein diese Forderung schränkt die Auswahl bereits massiv ein 
- konkret: Bei FOSC = 6 MHz kannst Du mit dem TC/1 im ATmega8 gerade mal 
läppische 94 ganzzahlig-exakte Frequenzen generieren. Unten sind sie 
alle aufgelistet.

Ganz schön enttäuschend, meinst Du? Ja, irgendwie schon. Aber: Einen 
Generator zu bauen, der schlicht diese Frequenzen erzeugt, ist immer 
noch ein gutes Lernprojekt, und auch einen Nutzwert hat so ein Teil 
durchaus. Nur die Tasten "+1 Hz" und "-1 Hz" und "+100 Hz" und "-100 
Hz": Die sind da - sozusagen "aus mathematischen Gründen" - fehl am 
Platz. Wenn Du das verstanden hast, dann hast Du wirklich etwas gelernt 
(ich würde als Steuerelement zur Kontrolle der Frequenz wahrscheinlich 
einen Endlos-Drehimpulsgeber nehmen. Aber mit zwei Tasten "-" und "+" 
geht es natürlich auch).


----------------------------
Alle ganzzahlig-exakten Output-Frequenzen für FOSC = 6000000 Hz.
In Klammern jeweils der OCR-Wert + 1 sowie der Prescaler-Wert.

3000000  (1, 1)
1500000  (2, 1)
1000000  (3, 1)
750000   (4, 1)
600000   (5, 1)
500000   (6, 1)
375000   (1, 8)
300000   (10, 1)
250000   (12, 1)
200000   (15, 1)
187500   (2, 8)
150000   (20, 1)
125000   (3, 8)
120000   (25, 1)
100000   (30, 1)
93750    (32, 1)
75000    (40, 1)
62500    (48, 1)
60000    (50, 1)
50000    (60, 1)
46875    (64, 1)
40000    (75, 1)
37500    (80, 1)
31250    (12, 8)
30000    (100, 1)
25000    (15, 8)
24000    (125, 1)
20000    (150, 1)
18750    (160, 1)
15625    (192, 1)
15000    (200, 1)
12500    (240, 1)
12000    (250, 1)
10000    (300, 1)
9375     (320, 1)
8000     (375, 1)
7500     (400, 1)
6250     (480, 1)
6000     (500, 1)
5000     (600, 1)
4800     (625, 1)
4000     (750, 1)
3750     (800, 1)
3125     (960, 1)
3000     (1000, 1)
2500     (150, 8)
2400     (1250, 1)
2000     (1500, 1)
1875     (1600, 1)
1600     (1875, 1)
1500     (2000, 1)
1250     (2400, 1)
1200     (2500, 1)
1000     (3000, 1)
960      (3125, 1)
800      (3750, 1)
750      (4000, 1)
625      (4800, 1)
600      (5000, 1)
500      (6000, 1)
480      (6250, 1)
400      (7500, 1)
375      (8000, 1)
320      (9375, 1)
300      (10000, 1)
250      (12000, 1)
240      (12500, 1)
200      (15000, 1)
192      (15625, 1)
160      (18750, 1)
150      (20000, 1)
125      (24000, 1)
120      (25000, 1)
100      (30000, 1)
96       (31250, 1)
80       (37500, 1)
75       (40000, 1)
64       (46875, 1)
60       (50000, 1)
50       (60000, 1)
48       (62500, 1)
40       (9375, 8)
30       (12500, 8)
25       (15000, 8)
24       (15625, 8)
20       (18750, 8)
15       (25000, 8)
12       (31250, 8)
10       (37500, 8)
8        (46875, 8)
6        (62500, 8)
5        (9375, 64)
3        (15625, 64)
1        (46875, 64)

[Marko E. (marko_e)]

Hallo LostInMusic

Alles was Du schreibst habe ich mittlerweile auch schon bemerkt, ausser 
dass meine Tabelle etwas länger ist und etwas anders aussieht.

Ich muss erst mal die Anregungen von euch umsetzen wie man überhaupt 
programmiert.

Drehimpulsgeber hatte ich gerade nicht, es klappt ja noch nicht einmal 
mit Tastern zufriedenstellend.

Mich würde natürlich trotzdem interessieren wie man einen Timer als 
einstellbaren Rechteckgenerator mit einer Auflösung von 1 Hz 
programmieren kann.

Kann man 2 Timer "hintereinander schalten" so dass die Auflösung höher 
wird?

Erschwerend kommt hinzu dass ich mir dachte, man könnte später versuchen 
das Tastverhältniss zu ändern.

Ist das Unsinn?

[Marko E. (marko_e)]

nochmal an LostInMusic

Der Lernwert ist enorm

ich weiss jetzt wie man datenreihen in LibreOffice erstellt,
desweiteren Diagramme
und Formeln aus Datentabellen generiert.

nutzt nur leider nichts für meinen Rechteckgenerator.

[Matthias S. (Firma: matzetronics) (mschoeldgen)]

Marko E. schrieb:
> Kann man 2 Timer "hintereinander schalten" so dass die Auflösung höher
> wird?

Das kann man schon, aber er wird dann aber nur länger - du kannst noch 
tiefere Frequenzen erzeugen.

Marko E. schrieb:
> nutzt nur leider nichts für meinen Rechteckgenerator.

Doch, warum nicht? Du kannst ja mal eine Formel erstellen, die die für 
eine gewünschte Ausgangsfrequenz die CTC und Prescalerwerte errechnet. 
Als Ausgangspunkt ist es natürlich am besten, eine 'magische' 
Taktfrequenz zu nehmen, die dir im Timer z.B. genau 100µs Zyklen 
erzeugt, das sind dann für 1Hz genau 5000 Zyklen (CTC toggelt ja, 
deswegen die Hälfte der Dauer in CTC). Für 2Hz dann 2500 Zyklen. Und 
dann fängts schon an. 3Hz wären 1666,66 Zyklen und das kriegt man nicht 
hin. Für genaue 3Hz müsste man 2 Perioden mit 1667 Zyklen fahren und 1 
mit 1666.
Ok, dann rechnet man mal statt mit 100µs mit 25µs Zyklen und schaut, ob 
das besser wird.

Und so weiter. Rechne mal ein bisschen und spiele mit den Taktfrequenzen 
und Vorteilerfaktoren in deiner Tabelle.
In meinem Generator bin ich den umgekehrten Weg gegangen. Ich setze CTC 
und Vorteiler von aussen und auf dem LCD errechnet mir der MC, welche 
Frequenz da gerade rauskommt.

[M. K. (sylaina)]

LostInMusic schrieb:
> Alle ganzzahlig-exakten Output-Frequenzen für FOSC = 6000000 Hz.
> In Klammern jeweils der OCR-Wert + 1 sowie der Prescaler-Wert.

Du könntest die Werte noch erweitern indem du nicht nur den 
Timer-Prescaler änderst sondern auch den Systemclock-Prescaler…aber 
schon eine schöne Erklärung, dank dafür. Sieht man eher weniger, dass 
sich jemand diese Mühe macht ;)

[Marko E. (marko_e)]

Hallo Mattias

Ich habe schon mit meiner Tabelle rumgespielt.
Herausgekommen ist dass ich den CTC für kleine Frequenzen sehr genau 
setzen kann. Funktioniert.
Bei höheren Frequenzen bin ich auch Deinen beschriebenen Weg gegangen 
dass ich mir die Frequenz fürs LCD und Ausgangsfrequenz aus dem CTC 
berechne. Funktioniert auch.


Marko

Ich möchte mich ganz herzlich bei allen Bedanken die mir mit Ihrem Rat 
zur Seite standen. Auch wenn mein Vorhaben nicht geklappt hat so habe 
ich doch eine Menge gelernt.

Eigentlich brauche ich nur mal einen Testgenerator mit 100 oder 200 khz.

Der Rechteckgenerator erzeugt die Frequenzen die ich benötige und es war 
eine Spinnerei von einem Anfänger 1 Hz genau einstellen zu wollen.

[M. K. (sylaina)]

Marko E. schrieb:
> Der Rechteckgenerator erzeugt die Frequenzen die ich benötige und es war
> eine Spinnerei von einem Anfänger 1 Hz genau einstellen zu wollen.

Überhaupt nicht. Ist doch völlig normal, dass hierbei die Neugier 
geweckt wird und man schaut was man noch so bekommen kann ;)