Ansprechen eines PLLs (LM7001)

[Dirk]

Hallo Michael,

kannst du bitte nochmal das angehängte Programm austesten.

Ich habe das Übertragungsprotokoll geändert. Daten-Word sowie Control-Word können einzeln übertragen werden, wobei zuerst das Control-Word übertragen wird.

Gruss
Dirk

 

[dg2ygq]

Ich habe heut den ganzen Nachmittag drann verbracht ....
Wieder ohne Erfolg.

Ich habe als Frequenz 15Mhz (15000) angegeben, als ControlWord habe ich nun fast alle Möglichkeiten durch.

Durch den Anschluss des SAA1057 an meinen Meßsender konnte ich den gesamten KW-Bereich abtasten.

Die VCO-Spannung am Ausgang bleibt immer bei 0,15V, egal was ich ihm "sage".

Die Anschlüsse habe ich Mehrfach kontrolliert, und mit dem PC-Programm funktioniert die Schaltung.

Irgendwas ist noch Faul an der Übertragung

 

[dg2ygq]

Heute hatte ich die SAA-Schaltung noch einmal neu aufgebaut, und sämtliche bisherige Programmversuche noch einmal probiert.
Ergebnis bleibt das selbe: Mit PC ja, Mit AVR nein.

Vielleicht hat ja noch jemand eine Idee ???

 

[Markus]

Hi Michael, hi Dirk,

so, hab mir das Datenblatt zum SAA nochmal reingezogen und versuche das ganze Thema mal aus der Ferne und meiner Perspektive aufzurollen. Hoffe es ist was dabei was hilft.

Ist "ferngesteuert" a bissle schwierig da ich nicht die gleiche HW hab aber...

Also, ich beziehe mich erst mal auf die Fragestellung

Also möchte der SAA erst LatchB und dann LatchA haben? Wird zu erst das 15. (links)oder 0.(rechts) Bit übertragen?

Der SAA hat zwei Möglichkeiten initialisiert zu werden:
1. Mindestens 10 Clock Takte auf den CLB Eingang und dann WordB schreiben
2. WordB schreiben.

Damit zu Deiner 1. Frage:
Damit der SAA das WordA überhaupt akzeptiert muss er über 1. oder 2. initialisiert sein. Da mir nicht ganz klar ist ob ich nach 2. nochmals das WordB schreiben muss würde ich auf jeden Fall 1. implementieren.
=> Wir basteln also eine Routine die erst mal nix anderes macht als mit dem entsprechenden Timing von 5µs oder mehr für CLBH und CLBL zu toggeln. Hab mal in Bascom ein paar Zeilen vorbereitet die soweit compilieren. Auf der HW testen konnte ich mangels HW nicht. Müßt Ihr ausprobieren. Der Code ist am Ende eingefügt.

Zu Deiner 2. Frage bzgl. der Bitrichtung:
Meiner Meinung nach geht aus dem Datenblatt ganz klar hervor, dass zuerst das MSB über die Leitung geschoben werden muss und das LSB zuletzt. Mit dem MSB (Bit 15) erfolgt die Steuerung ob es sich um WordB oder WordA handelt. Damit das ganze funktioniert muss aber für die Zeit "lead zero" ein zusätzliches Low-Bit (Startbit) gesendet werden.
Also mal schauen, ich versuche mal ne BASCOM-Gosub-Routine zu basteln die nix anderes macht als einen WORD-Wert (16 Bit) rauszuschieben. Damit ist das Ding universtell und kann für WordA und WordB verwendet werden.


Dumme Frage vorweg:
Du verwendest PortB.0 bis PortB.2. Ich gehe davon aus, das in Deinem Code nichts und niemand noch auf den Port zugreift und Du auch den Timer1 nicht so konfiguriert hast das er etwas von den PINs möchte. (Ich weiß, dumme Frage aber sicher ist sicher)


Weitere Fragestellungen:
[1] Wenn Ihr schreibt, das es mit der PC-Anbindung funktioniert dann würde ich erst mal klären ob das Config-WordB was Ihr über den ATmega schreiben wollt auch dem entspricht, was die PC-SW schickt. Habt Ihr da unterschiedliche Dateninhalte oder ist es das gleiche.

So, und nun wie weiter? Also los:
[1] In dem Basic-Beispiel aus Link

http://home.arcor.de/dg2ygq/pll-1.bas​

wird im wesentlichen auch nichts anderes gemacht als für eine Grundstellung gesorgt und dann das WordB rausgeschoben. Das Basic-Beispiel verzichtet auf die 10er Clock-Toggelung am Anfang aber ich finde sie schön und würde sie auch machen.
Zum Dateninhalt kann ich folgendes sagen:

Bit 15 = 1 'Latch B auswählen
Bit 14 = 0 'Fm Bit: AM Modus auswählen
Bit 13 = 0 'REFH: Zweites Bit Abstimmschritte 1khz auswählen
Bit 12 = 0 'Cp 3:=0
Bit 11 = 0 'Cp 2:=0
Bit 10 = 0 'Cp 1:=0
Bit 9 = 0 'Cp 0:=0
Bit 8 = 1 'SB2: Letzten 8 Bits (werden nich benötigt)
Bit 7 = 0 'SLA
Bit 6 = 1 'PDM1
Bit 5 = 0 'PDM0
Bit 4 = 1 'BRM
Bit 3 = 0 'T3
Bit 2 = 0 'T2
Bit 1 = 0 'T1
Bit 0 = 0 'T0
Word = &B1000000101010000 = &H8150

Ansonsten schreibt das Basic-Beispiel dann gleich noch den Wert 16000 in Word A. Damit müsste der SAA fertig initialisiert sein und funktionieren. Über das Timing kann man sich streiten. Verwendet wird hierfür der Shiftout-Befehl, dem ich sagen kann was ich auf welchem PIN rausschieben möchte, ob ich einen Clock erzeugen möchte und wie lange die ganze Operation dauern soll. Müsste so eigentlich auch funktionieren, nur mann müßte sich das unter dem Ozi mal ansehen ob der Clock auch wirklich passt.


[2] Das pollnische Beispiel aus dem microcontroller-Forum geht den Weg welchen ich auch favourisieren würde. Es gibt eine einzige Funktion mit der man auf den SAA zugreift und mit der man die Daten raus schiebt.

Das Beispiel hier verwendet die Initialisierung

Setup = 49605 ’&B1100000111000101

Das zu bewerten überlasse ich Euch, da seid Ihr vielleicht mehr die Spezialisten.

Also bauen wir im BASCOM-Code noch eine Routine welche Bits zum SAA raus schiebt. Und los

In meinem Beispielcode ziehe ich auch die globale Variable mit 10 µs an. Unter Umständen muss man hie rmit der zeit ein bissle spielen. Im pollnischen Beispiel werden mit 5 ms gearbeitet. Das gilt es einfach mal auszuprobieren.


Allgemeines:
[1] Ich bin ein Freund von definierten BUS-Zuständen. Da der ATmega bei RESET alle Beinchen hochohmig schaltet ist der Zustand der Signalleitungen undefiniert. Ich gehe hier sehr gerne hin und ziehe die Signalleitungen mit einem 10kOhm Widerstand auf GND so dass ich auf jeden Fall - egal was der ATmega macht - definierte Buszuständ hab.
[2] Nachdem Deine Schaltung mit dem PC funktioniert ist es sicherlich überflüssig die Beschaltung nach dem Datenblatt speziell im Hinblick auf die Bauteilwerte nochmals zu kontrollieren.
[3] Ich würde auf jeden Fall noch zwischen VCC und GND einen Entkopplung-C mit 100nF vorsehen. Das hat mir in der Vergangenheit bei so manchen Sensoren schon schöne Erlebnisse beschert und da lebe ich immer nach dem Prinzip Vorsicht statt nachsicht. Aber ich denke bzgl. Initialisierung ist das erst mal zweitrangig.

Und hier ist mein Beispiel wie wich es implementieren und testen würde. Wie gesagt, der Code ist compilierfähig aber ich weiß nicht ob er funktioniert und ob ich noch was vergessen habe weil ich habe keine HW und letzlich kann nur die Untersuchung mit dem Oszi aufschluss geben was wirklich rüber geht.

$regfile = "m8def.dat"
$crystal = 1000000

' Ressourcen festlegen
Dlen Alias Portb.0                                          'Dlen Leitung = Portb.0  'Anschluss 13
Clb Alias Portb.1                                           'Clock Leitung = Portb.1  'Anschluss 14
Dat Alias Portb.2                                           'Data Leitung = Portb.2   'Anschluss 12

' Wartezeit zwischen dem einzelnen Bitgezappel global festlegen
Bit_wait_time Alias 10

' Globale Variable definieren
Dim Temp_byte_1 As Byte

Dim Worda_frequency As Word
Worda_frequency = 16000

Dim Wordb_config As Word
Wordb_config = &H8150


' Prototypen definieren
Declare Sub Write_word_to_saa(byval Value As Word)

' Alle Anschlussleitungen als Ausgang konfigurieren
Config Dat = Output
Config Dlen = Output
Config Clb = Output

' Zuerst warten wir mal ein bissle
Waitms 100

' Erstmal Ruhe auf dem Datenbus
Reset Dlen
Reset Clb
Reset Dat

' Jetzt toggeln wir mal ein bisschen
For Temp_byte_1 = 1 To 16                                   ' zur Sicherheit 16 mal, das ist gut!
   Set Clb
   Waitus Bit_wait_time
   Reset Clb
   Waitus Bit_wait_time
Next Temp_byte_1

Call Write_word_to_saa(wordb_config)
Call Write_word_to_saa(worda_frequency)

' Hauptschleife
Do
   ' Tue nix
Loop

' Subroutine zum schreiben eines Word zum SAA
Sub Write_word_to_saa(byval Value As Word)

   ' lokale Variablen
   Local Countervalue As Byte
   Local Tempvalue As Byte

   ' Für Busruhe sorgen
   Reset Dlen
   Reset Clb
   Reset Dat
   Waitus Bit_wait_time

   ' Und los gehts, raus mit dem ersten Low-Bit (Startbit)
   Set Dlen
   Waitus Bit_wait_time

   Set Clb
   Waitus Bit_wait_time

   Reset Clb
   Waitus Bit_wait_time

   ' Und nun die Bits aus dem übergebenen Word rausschaufeln
   For Countervalue = 0 To 15
      ' Bit prozessieren und anlegen
      Rotate Value , Left , 1
      Tempvalue = Value And 1
      If Tempvalue = 0 Then
         Reset Dat
      Else
         Set Dat
      End If
      Waitus Bit_wait_time

      ' Takt erzeugen
      Set Clb
      Waitus Bit_wait_time

      Reset Clb
      Waitus Bit_wait_time

   Next A

   ' Daten Endsequenz senden

   Reset Dlen
   Waitus Bit_wait_time

   Set Clb
   Waitus Bit_wait_time

   Reset Clb
   Waitus Bit_wait_time

   Set Dlen
   Reset Dat
   Reset Clb
   Waitms 100

End Sub


End

So, ich hoffe ich konnte mit meinen Kommentaren ein wenig Beitrag leisten und Ihr haltet micht auf dem Laufenden was mit dem SAA weiter passiert.

Grüßle und viel Spass
Markus

 

[dg2ygq]

Hallo Markus,
ich glaube das jetzt nicht! Es funktioniert! Auf Anhieb

Die 10k Pulldown R`s werde ich noch einbauen, und dann wieder am Funkgerät anschließen.

/edit
Funktioniert am Gerät genau so GUT wie am Meßsender !

Muss LatchB jedes mal mit übertragen werden?
(Denke da an die Verzögerung, die das PLL benötigt, wenn ich auf TX gehe. Die möglichst gering halten.)

 

[Dirk]

Hallo ihr beiden,

das ist doch mal ein Erfolgserlebnis!

Ich habe nochmal bei meiner letzten Softwareversion nachgesehen, das "Bit" LeadingZero fehlt dort (StartBit), in der Version davor hatte ich es noch eingebaut Iniitialisiert hatte ich zwar dann mit Übertragung von LatchB und ausreichend Pause zu LatchA, aber das funktionierte dann natürlich nicht, wegen dem fehlenden StartBit.


Gruss
Dirk

 

[Markus]

Hallo Michael, Dirk,

habe mir Freude vernommen das das Beispiel funktioniert. Hat.

Ja da bin ich aber froh!!

Zur Frage bzgl. WordB:
Ich gehe nicht davon aus, dass man WordB jedes Mal zur Einstellung mitsenden muss. Das würde ich nicht machen sondenr ich würde WordB wirklich nur zur Initialisierung senden und dann nur noch WordA updaten.

Schaut Euch im Datenblatt aber nochmal das Thema "latch mode" an. Es geht wohl darum wann und wie das WordA gelatched wird. Besonders bei nierdrigen Frequenzen sollen hier wohl Störungen vermieden werden können.
Mehr verrate ich nicht denn den Rest bekommt Ihr auch ohne mich noch hin.

@Michael; wenn Du noch Tastenabfrage und sowas einbauen möchtest dann schau Dir mal den Debounce Befehl an den mann ganz toll in der Do-Loop Hauptschleife einbauen kann und mit dem man sehr elegant auf eine Gosub-Routine springen kann. Da läßt sich sehr schnell eine Tastensteurung realisieren mit der Du durch Frequenzband scannen kannst.

Grüße und schönes Wochenende,

Markus

 

[dg2ygq]

Soooooooo, da nun die Geschichte mit dem SAA 1057 geklappt hat, nun zurück zum LM 7001:

Hier noch mal das Datenblatt : http://pdf1.alldatasheet.com/datasheet-pdf/view/41210/SANYO/LM7001.html

Markus hatte beim SAA je ein Word für Frequenz, und ein Word für Config übertragen.
Nun hat der LM aber 14 Bit für die Frequenz, und 10Bit für die Config.
Das kann ich ja nun nicht in ein DWord für Frequenz, und ein Word für die Config packen, sind ja bei beiden einige Bits zuviel

Wie kann ich die Bits denn am besten aufteilen und übertragen?

Was ist mit den Anschlüssen BO1 bis BO3 bei dem LM 7001? Das sind doch "unbedeutende" Ausgänge, oder muss ich die auch noch irgendwie verschalten?

 

[Markus]

Hallo Michael,

ich gehe mal davon aus, dass Du bei dem Source-Code zur Übertragung der Daten in den SAA so ziemlich genau bei dem geblieben bist, was ich mir mal aus den Fingern gesaugt habe.

OK, schauen wir uns mal an was ich gemacht habe, hmmmm.

1. Zur Übetragung in den SAA hatte ich eine Funktion gebaut die nix anderes macht als 16 Bit, also ein WORD in den SAA zu plasen.
2. Diese Funktion hatten wir zwei Mal hintereinander verwendet um Konfiguration und Daten in den SAA zu schreiben.
3. Das eigentliche Übertragen der Bits zum SAA passierte nach dem Senden des Start-Bit in einer einzigen For-Schleife die von 0 bis 15 und damit 16x (für 16-Bit also) läuft.


Nun werfen wir man einen Blick auf den LM:

Freu Dich nicht zu früh, eine Komplettlösung gibts diesmal nicht. Heute ist Arbeiten angesagt

Der Blick in das Datenblatt vom LM verrät mir zunächst, das der nicht über getrennte Konfigurations- und Daten-Packet verfügt sondern alles in einem 24 Bit großen Paket enthalten hat.

So, nun einige Überlegungen für Dich zur Lösung Deines Problems:
- 16 Bit und damit ein WORD reichen nicht mehr aus.
- Die nächste größere vorzeichenlose Variable ist das LONG. Es besitzt 32 Bit. Ich weiß Du benötigst nur 24 Stück davon aber das ist auch nicht weiter schlimm. Mit der AND-Funktion lassen sich sehr schön Bits maskieren. Wenn Du nur 24 Bits brauchst dann definierst Du Dir anstelle des WORD halt ein einziges LONG und benutzt nur die Bits 0 - 23 und setzt die anderen mit AND &H00FFFFFF einfach auf 0.
- Durch Anpassung des Schleifenzählers auf 23 kannst Du dann genauso wie beim SAA aus der entsprechenden Variable die Bits zum LM schieben. Verstanden?
- So wie es aussieht ist der LM aber ein wenig dümmer wie der SAA und benötigt also auch kein Start-Bit für den Beginn einer "Sendung". Aber wie gesagt, ich habe mangels Zeit das Datenblatt nur kurz überflogen und Du sollst ja auch noch was dabei lernen. Bedeutet, Du kannst in meinem Code auf das Senden des Startbit verzichten.
- Du musst auf jeden Fall auch für BUS-Ruhe sorgen und bevor Du die Daten zum LM überträgst das das CE (Chip Enable oder Clock Enable oder was auch immer auf jedenfall das CE) von LOW (default) auf HIGH ziehen. Dann kannst Du die einzelnen Bits aus der Variable zum LM tackten.
- Damit hast Du auch eine Antwort auf die Frage, wie Du die Bits am besten aufteilen sollst.

Nun wird von Dir sicher die Frage kommen, wie Du die einzelnen Bits in die LONG-Variable bekommst
- Kein Problem!
- Du kannst mit den Befehlen SET und RESET einzelne Bits einer Variable setzenund zurücksetzen.
- Mit den Operationen AND und OR kannst Du ganze Bit-Bereiche z.B. mit anderen Variablen oder Konstanten auf 0 oder 1 oder ein anderes Bitmuster setzen.
- Mit dem Befehl SHIFT lassen sich die Bits einer Variable nach links oder rechts schieben um sie z.B. auf die richtige Position zu bringen. Ein Beispiel: VARIABLE AND &H00000000 setzt Dir eine gesamt LONG Variable auf NULL. Mit VARIABLE OR &HF werden die ersten 4 Bit (Bit0-3) auf HIGH gesetzt. Mit dem Befehl SHIFT Variable,Left,8 schiebst Du die eben gesetzten 4 Bits um 8 Bits nach links und damit nach oben und damit auf die Position Bit8-11. Üblicher Weise werden bei diesen Operationen immer Nullen nachgeschoben.
- Du siehst ganz einfach und umsonst ist nix

Als Antwort auf Deine Frage würde ich also sagen; "Durch geeignete Bit-Operationen und durch geeignete Addition von anderen Arbeitsvariablen. Hier ist ein wenig Mathematik im Binärsystem notwendig aber das ist kein Hexenwerk.
Wenn Du Probleme damit hast dann gehe runter bis auf die einzelnen Bits, male Dir ein Word als Binär-Zahl auf ein Papier und überlege Dir die einzelnen Schritte die notwneidg sind um 24 Bit mit den richtigen Inhalten zu füllen und zum LM zu übertragen.

Jetzt denke ich, hast Du genug Futter um hier erstmal loszulegen.

Ach ja, was ich Dir nicht sagen kann ist, was Du mit BO1 bis BO3 machen sollst. Dazu bin ich zu wenig Funker aber wenns bei der Binär-Mathematik klemmt dann kannst Du Dich gerne wieder melden.

Versuch mal meinen alten Code so umzubauen, dass Du einmalig 24 Bit zum LM übertragen kannst und erst dann würde ich mich mit dem Befüllen der 24 Bit auseinandersetzen. Erst die Musikinstrumente bauen und dann spielen.

Grüße,
Markus

 

[dg2ygq]

Freu Dich nicht zu früh, eine Komplettlösung gibts diesmal nicht. Heute ist Arbeiten angesagt

Nur Heute????

Nun hatte ich noch ein paar Fragen offen, die ich aber nun durchs mehrfache Lesen gefunden hab.

Also mach ich mich mal ans Werk ...

 

[Markus]

OK, alles klar -> und LOS

Wenns Ergebniss und/oder Neuigkeiten gibt dann lass es uns wissen. Wenn Du Lust hast dann mach mal ein Bild von Deinem Aufbau, würde mich sehr interessieren wie er aussieht und was Du bissher realisiert hast.

Grüße,
Markus

 

[dg2ygq]

Tja, meine Knipse streikt mal wieder ....
Hier einmal da Platinenlayout .....

ATMega8 mit dem SAA1057, Spannung stabilisiert mit einem 7805.
Up-Down-Schalter wird direkt an den Mega angelötet, die VFO-Ein/Ausgänge direkt an den SAA.
Ein Transi für TX-Umschaltung, 2Transis für Multiplexanzeige.
Die Widerstände für die 7Segment-Anzeige habe ich in SMD ausgeführt, spart das bohren

Jetzt müsst ich nur noch lernen mit einem guten PCB-Proggy umzugehen, zB Eagle, aber da bekomm ich noch garnichts aufs Blatt

 

[Markus]

Hi,

also EAGLE kann ich absolut empfehlen. Tolles Tool und auch für Privatanwendet absolut erschwinglich da Cadsoft zum einen eine eingeschränkte Studentenversion und Demoversion zur Verfügung stellt als auch eine so genannte "Non profit licence". Du muss dafür unterschreiben dass Du EAGLE nur für Dein Hobby und nicht gewerblich benutzt und bekommst das komplette Standardpaket inkl. Autorouter für ein paar Euro. Ich habe jetzt erst das Update auf die neue Version 5.0 für inkl. Versand und Verpackung 49 EUR bekommen. Da sage ich nur super und danke Cadsoft.

Und so schwer ist EAGLE nicht. Bei Eagle ist ein Trainingshandbuch dabei was schritt für schritt die wichtigsten Dinge wie in einer Art Lehrgang erläutert und ich glaube wenn man a bissle Ahnung von Elektronik hat dann kommt man da schon sehr schnell rein.
Ich denke das ist der Vorteil und die Stärke von EAGLE. Mann kann mit EAGLE sehr schnell und leicht einsteigen und schon ergebnisse erziehlen. Mann kann aber auch tief einsteigen und EAGLE als mächtiges Tool nutzen.
Ich finds toll und mags nie wieder missen!!

Grüße,
Markus

 

[Dirk]

Hallo,

da kann ich Markus nur zustimmen. Ich nutze auch Eagle und habe hiermit schon einige nette Projekte realisiert.

Wenn du dir erst mal eigene Bauteile (Devices) definiert hast, die du öfters verwendest und dir die Tastaturbelegung mit Befehlen nach deinen Wünschen eingestellt hast, geht die Schaltplanerstellung und das Routen sehr schnell. Wobei ich sagen muss, dass ich den Autorouter von Eagle sehr selten nutze, manchmal nur bei Bus-Strukturen, allerdings korrigiere ich hier dann auch manuell.

Grüße,
Dirk

 

[dg2ygq]

Erstes Gerät fertig !

DNT Cockpit, stammt aus den 80ern und hatte ursprünglich 40Ch....
Kabelführung noch etwas Queerbeet, und Layout noch überarbeitungswürdig.
Aber es funktioniert !!!
Hat natürlich duch diesen Eingriff keine Betriebserlaubnis mehr

 

[dg2ygq]

Noch mal wieder zurück zum 7001er:

xxxx1000100100 entpspricht also 145,
wenn ich nun aber 16270 haben möchte, welches Bitmuster ergibt das innerhalb dier 14 Bits ???

Im Datenblatt sind im AM-Bereich die ersten 4 Stellen "geixt", also Egal was drinn steht ?!
Demnach würde 16270 (im 1kHz Raster) oder auch 1627 (im 10kHz Raster) garnicht mehr gehen?

Dass die Bitwertigkeit wieder "rückwärts" geht, bringt mich ganz arg durcheinander.

Wie kann ich denn , wie in dem Beispiel, die "145" als Dezimalzahl aus einer Tabelle auslesen, und passend so drehen, wie es binär verlangt wird? Also auf 14 Bit "reduziert" und rückwärts ?

Hier mal mein Code zur Übertragung:

$regfile = "m8515.dat"
$crystal = 1000000
$baud = 300

Config Portb = Output
Config Portd = Input
Portd = &B11111111

Clock Alias Portb.1
Daten Alias Portb.2
Ce Alias Portb.0

Dim Freq As Long

Freq = &B00001000100100000000100000000000

Main:

Do
 Debounce Pind.0 , 0 , Pr , Sub
Loop

Pr:
Ce = 1
Shiftout Daten , Clock , Freq , 1 , 24 , 20000
Waitms 10
Ce = 0
Return
End

Ist also ne ganz einfache Übertragung mit Shiftout, funktioniert so gar
Das Programm wartet auf eine Taste, bevor es die Daten überträgt, eine andere Aufgabe hat Debounce nicht!

Aber diese ersten 14 Bit`s, die die Frequenz angeben, weiß ich noch nicht wie ich mit denen Umgehen soll?
Ich würde eben gerne Dezimalzahlen in der Tabelle haben, nur wie komme ich von der Dezimalzahl zum passenden "Binärdurcheinander" ?

Auch dass ich bei der Variable "Freq." hinter den vom 7001er benötigten 24 Bit noch 8Bit (ich hab mit Nullen gefüllt) anhängen muss, um die Longvariable voll zu kriegen, da muss es doch auch einen besseren Weg geben ?!

 

[Dirk]

Hallo Michael,

ich kenne mich mit Bascom leider nicht so aus, aber vielleicht bringen dich folgende Gedankengänge auf Ideen.

Für die Frequenz könnte man vielleicht eine Variable mit der Größe Word (16bit) definieren. Da passt dann auch 16270d (0b11111110001110) rein. Ich nenne die Variable mal FREQ.

Für die Übertragung der Frequenz definierst du entweder eine zweite Variable mit der Größe der zu übertragenden Daten, oder vielleicht besser mehrere 8Byte Variablen, die du nacheinander überträgst. ich nenne die Variablen (8Bit) mal DATA_A, DATA_B und DATA_C, es sind dann insgesamt 24bit.

Dann schreibst du eine Routine, die dir bitweise den Inhalt der Variable FREQ (16Bit) in die Variablen DATA_A, DATA_B und DATA_C kopiert, und zwar so, dass niederwertigste Bits die höherwertigen Bits ergeben und umgekehrt. Hier bräuchtest du keine Tabelle, die auch wahrscheinlich auf Grund der vielen möglichen Frequenzen ziemlich groß wäre.

In Assembler würden hier die Instructions bst/bld passen. Inwieweit das mit Bascom machbar ist, weiss ich jetzt im Moment nicht, da müsste ich in der Hilfe mal nachsehen, aber vielleicht hast du ja bereits eine Idee, wie man das lösen kann.

Grüße,
Dirk

 

[dg2ygq]

Hallo Dirk,

nein, ich habe noch keine Lösung.
Da das PLL für die AM-Frequenz keine 14Bits, sondern bloß 10Bits nimmt, kann das mit 0b11111110001110 nicht klappen.
Ich fürchte das kann ich mit diesem IC vergessen, so hohe Frequenzen in 1kHz-Schritte zu teilen.
10 Bits ergibt höchstens 1023, also kann ich nur bis gut 1Mhz in 1kHz, bzw bis gut 5Mhz in 5kHz Schritte teilen, oder verstehe ich das IC total falsch?
(Wäre vielleicht auch eine Erklärung warum das IC bloß 95ct kostet)

Nagut, bis 5Mhz in 5kHz-Schritten kann ich auch was wollen.

So lange die Bits nun aber "verdreht" sind, kann ich nicht einfach addieren und subtrahieren. Also ich muss die Bits verdrehen, glaub ich.
Für 80Kanäle würd sich eine Tabelle sicher noch anbieten, aber nicht mehr wenn man einen Frequenzbereich von 1 oder mehr Mhz durch scannen möchte.

Aufteilen in 3 Byte ist ja auch nicht so einfach! Die Frequenz wird ja in den ersten 14Bits bestimmt, wobei davon die ersten 4 ja wieder weg fallen, bzw immer mit Nullen gefüllt sind. Bleiben 10 Bits über.

Bascom versteht auch Asm-Befehle, ich weiß nur nicht wie man die Variablen übergibt, habe ich noch nie gemacht.

 

[Markus]

Hi Michael,

habe die letzten Tage Dein aktuelles Thema verfolgt, habe auch noch keine Patenlösung aber vieleicht einige Hinweise welche Dir weiterhelfen könnten:

1. Thema Shiftout
Beim Shiftout kannst Du angeben ob er das LSB oder das MSB zuerst raustacktet. Schau Dir das mal genau an. Vielleicht könnte dies eine mögliche Lösung für Deinen "Verdreher" der Bitwertigkeiten bei der Ansteuerung sein. Einfach richtig herum in der Variable ablegen und dann anders raustackten.
Vieleicht solltest Du die Bitmuster welche Du übertragen möchtest auch in Ihre Einzelteile zerlegen und separat und hintereinander zur PLL übertragen.
Ist nur mal so eine Idee.

2. Nullen füllen und LONG-Variablen:
Ich denke das es prinzipiell möglich ist durch Mathematik eine mit NULL initialisierte LONG-Variable elegant mit Dezimalzahlen zu befüllen. z.B. so:
- LONG-Variable x mit 0 vorbelegen
- Dezimalzahl aus Tabelle holen und eine temp. LONG-Variable übergeben.
- Wert viermal schieben und auf x addieren.
Hört sich doch gut an oder? Hmmm, vielleicht habe ich auch Dein Problem noch nicht richtig verstanden.

3. Bytes oder Words drehen:
Ich habe mal gesucht ob es eine feritige Funktion in BASCOM gibt welche Dir die Bits eines Bytes oder Words dreht. Leider bin ich in endlicher zeit nicht fündig geworden. Als habe ich mal schnell selbst was gestrickt, was sicher noch optimiert werden kann, was aber über eine Schleife und indizierte Bit-Zugriffe für ein Word genau das macht, nämlich drehen. Hier schicke ich Dir mal den Code. Ich habs im Simulator ausprobiert und da siehts gut aus. Vielleicht kannst Du den Code ja verwenden. Sicherlich lässt sich hieraus eine schöne Funktion mit Parameterübergabe stricken.

'------------------------------------------------------------------------------
$regfile = "m128def.dat"
$crystal = 16000000
$hwstack = 32
$swstack = 32
$framesize = 40

$baud = 38400

Dim Testword1 As Word
Dim Testword2 As Word
Dim Index As Byte
Dim Bitpos As Byte
Dim Bitvalue As Bit

Testword1 = &B1100110010101010

For Index = 0 To 15
   Bitvalue = Testword1.index
   Bitpos = 15 - Index
   Select Case Bitvalue
      Case 0 :
         Testword2.bitpos = 0
      Case 1:
         Testword2.bitpos = 1
   End Select
Next Index

'##############################################################################
' Hauptprogramm
'##############################################################################
Do
Loop
'## End Hauptprogramm #########################################################

'###################################### END ###################################

So ich glaube das wars erst mal wieder von mir. Vielleicht ist was dabei was Du verwenden kannst um Deine Bits und Bytes einfach zu addieren und subtrahieren und was auch immer und dann drehen und spiegeln und "nausjubeln" und .....

Viel Erfolgt und Grüße,
Markus

 

[dg2ygq]

Hallo Markus!

Das ist doch schon mal eine feine Idee:

Zuerst versuch ich es mal Umständlich:
- Ich übertrage mit dem ersten Durchgang 4 Nullen, da diese ja eh immer 0 sind.
- Ich übertrage rückwärts 8Bits mit der Frequenz
- nun die beiden T0 & T1
- zum Schluss B0 bis S

Das CE-Bit lasse ich high, bis alle 4 Datenpakete durch sind.

Durch das rückwärts übertragen der Bits D4 bis D11 sind diese Bits doch schon in der richtigen Reihenfolge


Nun auf deinen Punkt 2:

- Wert viermal schieben und auf x addieren.

Das 4mal schieben bezieht sich auf die ersten 4 Bits, die "wohl" 0 sein müssen, und bei meinem Byte einfach zuviel sind, ja?
Wie schieb ich denn ?