FSK CW mogelijk met vaste space Frekwentie ?

[QSY]

..

[coolepascal]

Hey Oene,
In het kader van een nieuw experiment ben ik altijd wel te vinden om mee te doen (alsof ik daar nog tijd voor heb)
Kun je eens wat meer over je geplande proeven vertellen.
b.v. als eerste waarom fsk-cw ? gevoelsmatig zijn er vooral nadelen tov normale CW, de enige winst die ik zie is de veel lagere storing die het veroorzaakt.

[QSY]

..

[coolepascal]

Oene, wat je eindtrap betreft, gewoon een classe C eindtrap met het zelfde vermogen gebruiken
(dus gewoon je ruststroom instelling drastisch veranderen)

Maar wat sleutelen betreft bedenk wel het volgende.
Als je flink heen en weer gaat wapperen met je carrier dan wordt je bandbreedte ook navanant.
ik heb daar wel wat ervaring mee met mijn frequentiehopping experimenten (dat lijkt al aardig op wat jij kenlijk van plan bent.

Om te beginnen zou ik dus kijken of je met een betere oplossing kan komen dan met een tweede stuurzendertje.
Kijk b.v. of je iets met een DDS kan doen (de DDS sleutelen tussen de twee frequenties, dit overrigens met behoud van bovengenoemd probleem)
Ik wil wel eens proberen wat er gebeurd als je over zo'n grote bandbreedte gaat sleutelen.
(heb nog een SDR RTTY projectje en ook een SDR CW generatortje, kwestie van software kopieren en wat dingen aanpassen, binnen een halfuurtje heb ik dat waarschijnlijk wel voor elkaar)

Ik dacht overigens dan de moderne maanbonzers met een psk-achtig computer programmaatje werkten.

[QSY]

..

[coolepascal]

Oene,

Hieronder een plaatje van mijn testresultaten.
Ik heb het volgende gebouwd.
Een callgever (12wpm die had ik al van een eerder experiment) de output ervan gaat naar een VCO, waarachter vervolgens een hilbert filter komt om het signaal complex te maken (ik had al ergens een complexe versie van de VCO maar die is nog steeds niet ingechecked)
Dan komt er een complex bandfilter van 0-55kHz met flanken van 1000Hz (bij een op die plaats geldende sample rate van 200kS/sec toch nog vrij heftig) en dat signaal gaat vervolgens naar de ADC (in mijn geval een USRP)

Met een tweede USRP (das gemakkelijker) heb ik het spectrum bekeken waarvan hieronder een plaatje.
Je moet aleen maar kijken naar het gebied tussen 432.100 en 432.400
Je ziet het bandfilter doet zijn werk.
Wat je helaas niet ziet is dat tussen 432.005 en 432.060 (dus tussen de paaltjes) een ontzettende klere-herrie van klikkerts ontstaat. dat was natuurlijk te verwachten, en daar zit ook jouw probleem.
Wat ik zou kunnen doen is twee bandfilters per freq toepassen (of een samengesteld filter for that mather) welicht dat het dan een stuk beter gaat, maar dan moet ik er nog een uurtje tegenaan gooien, en zoveel koffie heb jij echt niet in huis !



Ohhh ja wat het FaseLusSSB power probleem betreft, ik heb gewoon een classe C eindtrap gebruikt. en je hebt dus niet eens meer een dure lineare eindtrap nodig.
Dat moet bakkiebouwers toch aanspreken.

[coolepascal]

Voor het zeer onwaarschijnlijke geval dat iemand geintereseerd zou zijn in de code van dit
experiment.
Het maakt gebruik van het open source paket GNU-Radio, voor iedereen vrijelijk te downloaden en te gebruiken, dat geld trouwens ook voor onderstaande code, ik doe niet zo moeilijk als sommige zendamateurs.

Overigens, je ziet SDR is helemaal niet zo moeilijk als op de band altijd beweerd wordt.

Code: Selecteer alles

#!/usr/bin/python
# Title    : FSKCW_Beacon.py
# Function : Test voor Oene
# Author   : CoolePascal (C) 2010 gnu/gpl

from gnuradio import gr 
from gnuradio import usrp
from gnuradio.wxgui import stdgui2, scopesink2
from math import pi

# Main Graph
class fskcw_graph(stdgui2.std_top_block):

        # Constructor
	def __init__(self, frame, panel, vbox, argv):
		# Graphical part
		stdgui2.std_top_block.__init__(self, frame, panel, vbox, argv)

		# Config          
		tx_frequency  = 432210000
                usrp_dac_rate = 128000000
		usrp_adc_rate =  64000000
                usrp_interpolation = 400
		usrp_decimation = 200
                tx_side = 1
                tx_dev = 0
                audio_rate = 32000
		#
		usrp_tx_rate = usrp_dac_rate / usrp_interpolation
		usrp_rx_rate = usrp_adc_rate / usrp_decimation
		tx_subspec=(tx_side,tx_dev)
		rx_subspec=(tx_side,tx_dev)
		#
		def cw_keyer_f(samplerate,speed,data):
			dotsamples=samplerate/speed

			wavedata = []
			for x in data:
				samples=0
				amplitude=0
				if(x == '.'):
					samples = dotsamples
					amplitude=1
				if(x == '-'):
                                        samples = dotsamples*3
                                        amplitude=1
				if(x == ' '):
                                        samples = dotsamples*2
                                        amplitude=0
				if(x == '_'):
                                        samples = dotsamples*100
                                        amplitude=1 
				for y in range(0, samples):
					wavedata.append(amplitude)
				for y in range(0,dotsamples):
					wavedata.append(0)
			return gr.vector_source_f(wavedata, True)

		#
		callgever = cw_keyer_f(usrp_tx_rate,12,".--. .- ...-- ..-. -.- --   .--- --- ..--- ----- -..- ...- _ ")
		#

		fsk_f = gr.vco_f(usrp_tx_rate, 55000*2*pi, 5000)

		fsk_c = gr.hilbert_fc(usrp_tx_rate/10000)
		ftoc = gr.float_to_complex()

		# Low pas filter to get rid of keyclicks
                filter_coeffs = gr.firdes.complex_band_pass(1,
                                                   usrp_tx_rate,
                                                    0,
                                                    55000,
                                                    1000)

                bpf_c = gr.fir_filter_ccc (1, filter_coeffs)

		# Transmitter
		usrp_tx = usrp.sink_c(0,usrp_interpolation)
		self.usrp_tx = usrp_tx
		usrp_tx_subdev = usrp.selected_subdev(usrp_tx,tx_subspec)
                mux = usrp.determine_tx_mux_value(usrp_tx,tx_subspec)
                usrp_tx.set_mux(mux)
                usrp_tx.tune(tx_side, usrp_tx_subdev, tx_frequency)
		usrp_tx_subdev.set_enable(True)

		# Connect all stuff
		self.connect(callgever, fsk_f, fsk_c, bpf_c, usrp_tx)

# Main caller program
if __name__ == '__main__':
	aplication = stdgui2.stdapp(fskcw_graph,"432MHz FSKCW_Beacon")
	aplication.MainLoop()

Het indenten (heel relevant bij python) klopt niet helemaal
het gevolg van door elkaar gebruiken van spaties en tabs, ach er is toch niemand die dat opvalt

[QSY]

..

[coolepascal]

Hi Oene,

Kijk nog even naar het plaatje (het is idd een heel gedoe om dat goed te krijgen)
De groene lijn is de peak (bij de instellingen kun je zien dat peak hold aan staat)
Dit wil ruwweg zeggen dat beide paaltjes zichtbaar blijven hetgeen jij als twee carriers ziet, maar er is er slechts een tegelijk in de lucht.
het blauw paaltje is het signaal zoals het was op het moment dat ik de momentopname maakte.
Het is dus gewoon een fsk signaal (op precies de zelfde manier heb ik ook al eens rtty gemaakt, vandaar dat ik redelijk vlug wist hoe ik het experiment kon opzetten)

Ik moet je echter waarschuwen voor de oplossing die jij hoopt te gebruiken om je fsk te maken !
reken er maar op dat je een hoop troep veroorzaakt, daar heb ik met mijn frequentie hoppende experimenten genoeg van mee gekregen.
Je kunt n.l. kiezen uit twee kwalen:

1) Je hebt een perfecte oplossing die tijdloos tussen de twee frequenties schakelt.
Met SDR is dat een makkie, ik schakelde tijdens de 0 doorgangen van freq.
Het nadeel hiervan is dat je in een oneindige korte tijd van freq wisselt en dus een oneindig breede puls veroorzaakt.

2) je schakelt smooth tussen beide frequenties en je veroorzaakt geen storing.
Dit heeft echter tot gevolg dat beide frequenties elkaar kortstondig overlappen of alternatively er een kortstondige onderbreking is.
Beiden vertalen zich in amplitude verschillen lees Boze Buurmeisjes en dat voorkomen daar was het nu net allemaal om te doen

Tegen oplossing 1 is wel wat te doen middels smalle filters waar precies de mark en space frequentie in passen en welke pakweg 200Hz breed zijn.

Wat je zou kunnen doen is net als ik voor een VCO-FSK oplossing kiezen.
Je bouwt een VCO op 10.7MHz en met met een potmetertje stel je de hoogste freq af, en met key down komt er een tweede potje bij waarmee de je laagste freq afstelt (desgewenst key signaal reversen, of de common van je seinsleutel aan +ref hangen)
Vervolgens zorg je dat er achter je fsk_vco een tweetal parallelle bandfiltertjes komen.
Dat moeten dan wel echt heel stoere filtertjes zijn mischien kun je iets doen met twee verschillende zijband xtalletjes.

Of het allemaal mag weet ik niet houd ik me ook totaal niet mee bezig.
Ik rammel netjes me identificatie en als ik iets van plan ben waar mensen mogelijk moeilijk over zouden kunnen doen, dan bel ik wel even met het AT.
In jouw geval zou ik me al helemaal niet druk maken, beide signalen zijn immers voorzien van je skipnaam (ook al is er een in reverse)

Overigens zie ik niet echt een winst met een grote freq afstand,
ik denk als je iets van pffff pak ehm beet 10kHz aan houdt je idee best te proberen valt

Wat de moeite betreft, ach het is een leuk experiment en weer es wat anders he.
ben benieuwd of er nog meer lui zijn die iets over hun experimenten te melden hebben.
Laat maar eens weten wat je er uiteindelijk mee gaat doen Oene