Example #1
0
func (s *setup) SimulateLink(SNR float64, pdp vlib.VectorF, spcode vlib.VectorC, uid int) float64 {
	var cdma core.CDMA
	bitTs := 1.0
	cdma.InitializeChip()

	cdma.SetSpreadCode(spcode, true)
	var mpchannel core.MPChannel
	mpchannel.InitializeChip()
	///
	param := core.NewIIDChannel()
	param.SetPDP(pdp)
	param.Mode = "iid"
	symbolTs := 2 * bitTs
	param.Ts = 5 * symbolTs // bitTs // dataArray.Ts * float64(BlockSize)
	mpchannel.InitParam(param)

	var modem core.Modem

	modem.InitializeChip()
	modem.InitModem(2)

	feedback := make(gocomm.Complex128AChannel, 10)
	mpchannel.SetFeedbackChannel(feedback)
	modem.SetFeedbackChannel(feedback)

	bitsample := vlib.VectorB(sources.RandB(s.BlockSize))
	bitChannel := gocomm.NewBitChannel()
	var dataArray gocomm.SBitObj
	dataArray.MaxExpected = bitsample.Size()
	dataArray.Message = fmt.Sprintf("Src %f  ", SNR)
	dataArray.Ts = bitTs
	dataArray.MaxExpected = s.BlockSize
	// fmt.Printf("bits=%v", bitsample)

	go (func(bitChannel gocomm.BitChannel) {
		for i := 0; i < s.BlockSize; i++ {
			dataArray.Ch = bitsample[i]

			// fmt.Printf("\n Transmitting .. %v", dataArray)
			bitChannel <- dataArray

			// modem.ModulateFn(dataArray)
			// symCH <- dataArray
			dataArray.TimeStamp += dataArray.Ts
		}
	})(bitChannel)

	go modem.Modulate(bitChannel)
	// fmt.Printf("Generated Bits", samples)
	symCH := chipset.ToComplexCH(modem.PinByName("outputPin0"))
	go cdma.Spread(symCH)

	OutCH := chipset.ToComplexACH(cdma.PinByID(2))
	ch1 := gocomm.NewComplex128Channel()
	go gocomm.ComplexA2Complex(OutCH, ch1)
	/// Add Multipath channel
	go mpchannel.Channel(ch1)
	ch2 := chipset.ToComplexCH(mpchannel.PinByName("outputPin0"))
	/// Add Noise
	noiseDb := 1.0 / dsp.InvDb(SNR)
	// fmt.Printf("\n %f AWGN Noise : %f", SNR, noiseDb)
	var awgn channel.ChannelEmulator
	awgn.SetNoise(0, noiseDb)
	awgn.InitializeChip()

	go awgn.AWGNChannel(ch2)
	ch3 := chipset.ToComplexCH(awgn.PinByID(1))

	// go awgn. (1/noiseDb, samples)

	go cdma.DeSpread(ch3)
	ch4 := chipset.ToComplexCH(cdma.PinByID(3))
	//go sink.CROremote(cdma.PinByID(3))

	go modem.DeModulate(ch4)
	ch5 := chipset.ToComplexCH(modem.PinByID(3)) // .Channel.(gocomm.Complex128Channel)
	// gocomm.WGroup.Add(1)

	// gocomm.WGroup.Add(1)
	// go gocomm.SinkComplex(ch4, "")
	// ///
	// bitsample
	var BER core.BER
	BER.TrueBits = bitsample
	BER.InitializeChip()
	ch6 := gocomm.NewBitChannel()
	BER.Reset()
	go BER.BERCount(ch6)
	go (func(ch6 gocomm.BitChannel) {
		count := 1
		for i := 0; i < count; i++ {
			data := <-ch5
			count = data.MaxExpected
			//fmt.Printf("\n sym received %#v", data)
			rxbits := gocomm.Complex2Bits(data)
			// fmt.Printf("\n bits converted received %#v", rxbits)
			ch6 <- rxbits[0]
			ch6 <- rxbits[1]
			// dec := gocomm.Complex2Bits(data)
			// result[2*i] = dec[0]
			// result[2*i+1] = dec[1]

			// fmt.Printf("\n %v", gocomm.Complex2Bits(data))

		}

	})(ch6)
	ch7 := chipset.ToFloatCH(BER.PinByName("outputPin0"))
	count := 1
	// result := vlib.NewVectorB(BlockSize)
	var result float64 = 0
	for i := 0; i < count; i++ {

		err := <-ch7
		count = err.MaxExpected
		// fmt.Printf("\nerr=(%f,%v) %#v", err.TimeStamp, err.Ch, err)
		result = err.Ch
	}
	// err := float64(bitsample.CountErrors(result)) / float64(BlockSize)
	// fmt.Printf("\ntxbits=%v", bitsample)
	// fmt.Printf("\nrxbits=%v", result)
	// fmt.Printf("\nErr=%v %v", bitsample.CountErrors(result), err)
	// gocomm.WGroup.Wait()
	if uid == 0 {
		s.snr_ber[SNR] += result
	} else {
		s.snr_ber1[SNR] += result
	}

	// snr_ber[SNR] /= s.snr_block[SNR]
	s.updateTable()
	// fmt.Printf("\r BLOCK %v \n BER : %v", s.snr_block, snr_ber)
	return result
}
Example #2
0
func main() {

	rand.Seed(time.Now().Unix())
	// rand.Seed(1)

	start := time.Now()
	var N = 10
	var N0 float64 = 1.0 / 10
	txbits := vlib.VectorB(sources.RandB(N))

	qpskModem := new(core.Modem)
	var BitsPerSymbol = 2
	qpskModem.Init(BitsPerSymbol, "")
	fmt.Printf("\n%v", qpskModem)

	/// Take every N-bit and push to modem-channel-demod

	length := len(txbits)
	// slength := length / BitsPerSymbol

	//var result = make([]complex128, slength)
	/// Actual Modulation happens here

	cnt := 0
	// rxcnt := 0
	// symCH := make([]chan complex128, length)
	COUNT := length / 2
	rxCH := make([]chan []uint8, COUNT)

	for i := 0; i < COUNT; i++ {
		rxCH[i] = make(chan []uint8)
	}

	for i := 0; i < length; i += BitsPerSymbol {

		symCH := make(chan complex128)

		go qpskModem.GenerateSymbolCH(cnt, txbits[i:i+BitsPerSymbol], symCH)
		go func(twowayChannel chan complex128, cnt int) {

			symbol := <-twowayChannel
			noise := sources.RandNC(N0)
			fmt.Printf("\n Added Noise %d %v", cnt, noise)
			rxsymbol := symbol + noise
			twowayChannel <- rxsymbol
		}(symCH, cnt)
		go qpskModem.DemodSymbolCH(cnt, symCH, rxCH[cnt])

		cnt++
	}

	ORDER := true
	//// UNORDERED receiver bits...
	for i := 0; i < COUNT; i++ {

		if ORDER {
			func(cnt int, tmpRxCh chan []uint8) {
				for rxbits := range tmpRxCh {
					fmt.Printf("\n Unordered Loop Detected bits %d %v", cnt, rxbits)
				}

			}(i, rxCH[i])
		} else {
			go func(cnt int, tmpRxCh chan []uint8) {
				for rxbits := range tmpRxCh {
					fmt.Printf("\n Unordered Loop Detected bits %d %v", cnt, rxbits)
				}

			}(i, rxCH[i])
			fmt.Printf("Waiting for routines to finish")
			time.Sleep(2 * time.Second)

		}
	}

	/// Ordered read from the Receiver channels
	// cnt = 0
	// for _, channel := range rxCH {

	// 	for rxbits := range channel {
	// 		fmt.Printf("\n Outer Loop Detected bits %d %v", cnt, rxbits)
	// 	}
	// 	cnt++
	// }

	// txsymbols := qpskModem.ModulateBits(txbits)
	// rxsymbols := vlib.ElemAddCmplx(txsymbols, sources.Noise(len(txsymbols), N0))
	// rxbits := qpskModem.DeModulateBits(rxsymbols)

	// // fmt.Printf("\nTx=%v", txbits)
	// // fmt.Printf("\nRx=%v", rxbits)
	// fmt.Printf("\nERR=%v/%d = %f", txbits.CountErrors(rxbits), len(txbits), float64(txbits.CountErrors(rxbits))/float64(len(txbits)))
	fmt.Printf("\n\n Elapsed %v \n", time.Since(start).String())
}