func main() {
N := 2048
begin := time.Now()
var ofdm customchips.OFDM
ofdm.InitializeChip()
ofdm.NPoint = N
// fmt.Printf("\n OFDM = %v", ofdm)
/// Input
inCHA := gocomm.NewComplex128AChannel()
// inCH := gocomm.NewComplex128Channel()
var dataArray gocomm.SComplex128AObj
x := sources.RandNCVec(N, 1)
dataArray.Ch = x
dataArray.MaxExpected = 1
inCHA <- dataArray
go ofdm.Ifft(inCHA)
go ofdm.Fft(ofdm.PinByName("outputPin0").Channel.(gocomm.Complex128AChannel))
outCHA := ofdm.PinByName("outputPin1").Channel.(gocomm.Complex128AChannel)
data := <-outCHA
/// Analyse
fmt.Printf("\nX=%f", x[0:16])
fmt.Printf("\nOutput=%f", data.Ch[0:16])
// xcap := dsp.ExtFFT_C(data.Ch, N)
// fmt.Printf("\nXcap=%f", xcap[0:16])
fmt.Printf("\nTime Elapsed : %v\n", time.Since(begin))
}
func (cdma *CDMA) Spread(chInway gocomm.Complex128Channel, OutCH gocomm.Complex128AChannel) {
indata := <-chInway
insymbol := indata.Ch
spcode := cdma.SpreadSequence
var result = make([]complex128, len(spcode))
for i := 0; i < len(spcode); i++ {
result[i] = insymbol * spcode[i]
}
var chdataOut gocomm.SComplex128AObj
chdataOut.Ch = result
chdataOut.MaxExpected = indata.MaxExpected / len(spcode)
// chdataOut.MaxExpected = int(math.Floor(float64(indata.MaxExpected) / float64(len(spcode))))
OutCH <- chdataOut
}
func (m *MPChannel) ChannelFn(sample gocomm.SComplex128Obj) (result gocomm.SComplex128Obj) {
/// Read your data from Input channel(s) [inputPin0]
/// And write it to OutputChannels [outputPin0]
// fmt.Printf("\n Channel Param %#v \n input = %v", m.ChannelParam, sample)
if m.Ts == -1 {
m.Coeff.Resize(m.pdp.Size())
for i := 0; i < m.pdp.Size(); i++ {
m.Coeff[i] = sources.RandNC(m.pdp[i])
}
if m.FeedbackCH != nil {
var chdata gocomm.SComplex128AObj
chdata.Ch = m.Coeff
chdata.TimeStamp = m.TimeStamp
chdata.MaxExpected = sample.MaxExpected
chdata.Ts = m.Ts
fmt.Printf("\n FAST IID generated for sample@%v with %v@%v", sample.TimeStamp, m.TimeStamp, cmplx.Abs(m.Coeff[0])*cmplx.Abs(m.Coeff[0]))
m.FeedbackCH <- chdata
}
} else {
m.updateCoeff(sample.TimeStamp)
}
if m.FilterMemory.Size() != m.Coeff.Size() {
m.FilterMemory.Resize(m.Coeff.Size())
}
result = sample /// Carefull if not same ChType
// m.TimeStamp = sample.TimeStamp
m.FilterMemory = m.FilterMemory.ShiftLeft(sample.Ch)
//dummy := vlib.ElemMultC(m.Coeff, vlib.Conj(m.Coeff))
foutput := vlib.DotC(m.Coeff, m.FilterMemory)
// fmt.Printf("\n CHANNEL @%v: I/P %v - Gain : %v : O/p : %v", sample.TimeStamp, sample.Ch, cmplx.Abs(m.Coeff[0])*cmplx.Abs(m.Coeff[0]), foutput)
result.Ch = foutput
result.Message = sample.Message + " Filter"
result.Ts = sample.Ts
result.TimeStamp = sample.TimeStamp
result.MaxExpected = sample.MaxExpected
// fmt.Printf("\n I/O (hn =%v) : %#v --> %#v", m.Coeff, sample, result)
return result
}
func (cdma *CDMA) SpreadBlock(expectedInputSymbols int, chInway gocomm.Complex128Channel, OutCH gocomm.Complex128AChannel) {
spcode := cdma.SpreadSequence
if len(spcode) == 0 {
panic("Spreading Code not Set")
}
for i := 0; i < expectedInputSymbols; i++ {
indata := <-chInway
insymbol := indata.Ch
var result = make([]complex128, len(spcode))
for i := 0; i < len(spcode); i++ {
result[i] = insymbol * spcode[i]
}
var chdataOut gocomm.SComplex128AObj
chdataOut.Ch = result
OutCH <- chdataOut
}
close(chInway)
}
func (m *OFDM) Fft(inputPin1 gocomm.Complex128AChannel) {
/// Read your data from Input channel(s) [inputPin1]
/// And write it to OutputChannels [outputPin1]
outputPin1 := m.Pins["outputPin1"].Channel.(gocomm.Complex128AChannel)
iters := 1
for i := 0; i < iters; i++ {
chData := <-inputPin1
iters = chData.MaxExpected
tsamples := chData.Ch
/// Do process here with chData
var outData gocomm.SComplex128AObj
outData.Ch = dsp.ExtFFT_C(tsamples, m.NPoint)
/// copy meta
outData.MaxExpected = chData.MaxExpected
outData.Ts = chData.Ts
outData.TimeStamp = chData.TimeStamp
outData.Message = chData.Message
outputPin1 <- outData
iters = chData.MaxExpected
}
}
func (m *MPChannel) updateCoeff(timestamp float64) {
/// first time
generated := false
if m.TimeStamp == -1 {
m.Coeff.Resize(m.pdp.Size())
for i := 0; i < m.pdp.Size(); i++ {
m.Coeff[i] = sources.RandNC(m.pdp[i])
}
generated = true
m.TimeStamp = 0 /// Unusuall if inbetween the MPchannel timestamp has got RESET !!
} else {
/// Existing channel-coeff is valid till m.Timestamp+m.TS,
valid := timestamp < (m.TimeStamp + m.Ts)
if !valid {
/// TRIGGER NEW COEFF
m.Coeff = vlib.NewVectorC(m.pdp.Size())
for i := 0; i < m.pdp.Size(); i++ {
m.Coeff[i] = sources.RandNC(m.pdp[i])
}
m.TimeStamp = timestamp
generated = true
}
}
/// Write new coeff to feedback channel if new was generated
if m.FeedbackCH != nil && generated {
var chdata gocomm.SComplex128AObj
chdata.Ch = m.Coeff
chdata.TimeStamp = m.TimeStamp
chdata.Ts = m.Ts
// fmt.Printf("\n CH:GENERATED @ %v with Coeff : %v, Gain : %v ", timestamp, m.Coeff[0], cmplx.Abs(m.Coeff[0])*cmplx.Abs(m.Coeff[0]))
m.FeedbackCH <- chdata
}
}
func (m *MPChannel) Channel(inputPin0 gocomm.Complex128Channel) {
/// Read your data from Input channel(s) [inputPin0]
/// And write it to OutputChannels [outputPin0]
outputPin0 := chipset.ToComplexCH(m.Pins["outputPin0"])
var IdealChObj gocomm.SComplex128AObj
iters := 1
for i := 0; i < iters; i++ {
chData := <-inputPin0
iters = chData.MaxExpected
/// Do process here with chData
outData := m.ChannelFn(chData)
/// coeff attempt to send
IdealChObj.Ch = m.Coeff
IdealChObj.Ts = chData.Ts
IdealChObj.TimeStamp = chData.TimeStamp
IdealChObj.Message = chData.Message
IdealChObj.MaxExpected = chData.MaxExpected
//fmt.Printf("\n Want to broadcast %#v to %#v", IdealChObj, coeffPin)
///
// select {
// case coeffPin <- IdealChObj:
// // fmt.Printf("\n%f : sent message %v", IdealChObj.TimeStamp, IdealChObj.Ch)
// default:
// // fmt.Printf("\n%f: no message sent", IdealChObj.TimeStamp)
// }
outputPin0 <- outData
}
}