1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
|
/*
* Copyright 2008 Free Software Foundation, Inc.
*
* This software is distributed under multiple licenses; see the COPYING file in the main directory for licensing information for this specific distribuion.
*
* This use of this software may be subject to additional restrictions.
* See the LEGAL file in the main directory for details.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
*/
#include "sigProcLib.h"
#include "GSMCommon.h"
#include "LinkedLists.h"
#include "radioDevice.h"
/** samples per GSM symbol */
#define SAMPSPERSYM 1
#define INCHUNK (625)
#define OUTCHUNK (625)
/** class used to organize GSM bursts by GSM timestamps */
class radioVector : public signalVector {
private:
GSM::Time mTime; ///< the burst's GSM timestamp
public:
/** constructor */
radioVector(const signalVector& wVector,
GSM::Time& wTime): signalVector(wVector),mTime(wTime) {};
/** timestamp read and write operators */
GSM::Time time() const { return mTime;}
void time(const GSM::Time& wTime) { mTime = wTime;}
/** comparison operator, used for sorting */
bool operator>(const radioVector& other) const {return mTime > other.mTime;}
};
/** a priority queue of radioVectors, i.e. GSM bursts, sorted so that earliest element is at top */
class VectorQueue : public InterthreadPriorityQueue<radioVector> {
public:
/** the top element of the queue */
GSM::Time nextTime() const;
/**
Get stale burst, if any.
@param targTime The target time.
@return Pointer to burst older than target time, removed from queue, or NULL.
*/
radioVector* getStaleBurst(const GSM::Time& targTime);
/**
Get current burst, if any.
@param targTime The target time.
@return Pointer to burst at the target time, removed from queue, or NULL.
*/
radioVector* getCurrentBurst(const GSM::Time& targTime);
};
/** a FIFO of radioVectors */
class VectorFIFO {
private:
PointerFIFO mQ;
Mutex mLock;
public:
unsigned size() {return mQ.size();}
void put(radioVector *ptr) {ScopedLock lock(mLock); mQ.put((void*) ptr);}
radioVector *get() { ScopedLock lock(mLock); return (radioVector*) mQ.get();}
};
/** the basestation clock class */
class RadioClock {
private:
GSM::Time mClock;
Mutex mLock;
Signal updateSignal;
public:
/** Set clock */
//void set(const GSM::Time& wTime) { ScopedLock lock(mLock); mClock = wTime; updateSignal.signal();}
void set(const GSM::Time& wTime) { ScopedLock lock(mLock); mClock = wTime; updateSignal.broadcast();;}
/** Increment clock */
//void incTN() { ScopedLock lock(mLock); mClock.incTN(); updateSignal.signal();}
void incTN() { ScopedLock lock(mLock); mClock.incTN(); updateSignal.broadcast();}
/** Get clock value */
GSM::Time get() { ScopedLock lock(mLock); return mClock; }
/** Wait until clock has changed */
//void wait() {ScopedLock lock(mLock); updateSignal.wait(mLock,1);}
// FIXME -- If we take away the timeout, a lot of threads don't start. Why?
void wait() {ScopedLock lock(mLock); updateSignal.wait(mLock);}
};
/** class to interface the transceiver with the USRP */
class RadioInterface {
private:
Thread mAlignRadioServiceLoopThread; ///< thread that synchronizes transmit and receive sections
VectorFIFO mReceiveFIFO; ///< FIFO that holds receive bursts
RadioDevice *mRadio; ///< the USRP object
short *sendBuffer; //[2*2*INCHUNK];
unsigned sendCursor;
short *rcvBuffer; //[2*2*OUTCHUNK];
unsigned rcvCursor;
bool underrun; ///< indicates writes to USRP are too slow
bool overrun; ///< indicates reads from USRP are too slow
TIMESTAMP writeTimestamp; ///< sample timestamp of next packet written to USRP
TIMESTAMP readTimestamp; ///< sample timestamp of next packet read from USRP
RadioClock mClock; ///< the basestation clock!
int samplesPerSymbol; ///< samples per GSM symbol
int receiveOffset; ///< offset b/w transmit and receive GSM timestamps, in timeslots
int mRadioOversampling;
int mTransceiverOversampling;
bool mOn; ///< indicates radio is on
double powerScaling;
bool loadTest;
int mNumARFCNs;
signalVector *finalVec, *finalVec9;
/** format samples to USRP */
short *radioifyVector(signalVector &wVector, short *shortVector, double scale, bool zeroOut);
/** format samples from USRP */
void unRadioifyVector(short *shortVector, signalVector &wVector);
/** push GSM bursts into the transmit buffer */
void pushBuffer(void);
/** pull GSM bursts from the receive buffer */
void pullBuffer(void);
public:
/** start the interface */
void start();
/** constructor */
RadioInterface(RadioDevice* wRadio = NULL,
int receiveOffset = 3,
int wRadioOversampling = SAMPSPERSYM,
int wTransceiverOversampling = SAMPSPERSYM,
GSM::Time wStartTime = GSM::Time(0));
/** destructor */
~RadioInterface();
void setSamplesPerSymbol(int wSamplesPerSymbol) {if (!mOn) samplesPerSymbol = wSamplesPerSymbol;}
int getSamplesPerSymbol() { return samplesPerSymbol;}
/** check for underrun, resets underrun value */
bool isUnderrun() { bool retVal = underrun; underrun = false; return retVal;}
/** attach an existing USRP to this interface */
void attach(RadioDevice *wRadio, int wRadioOversampling) {if (!mOn) {mRadio = wRadio; mRadioOversampling = SAMPSPERSYM;} }
/** return the receive FIFO */
VectorFIFO* receiveFIFO() { return &mReceiveFIFO;}
/** return the basestation clock */
RadioClock* getClock(void) { return &mClock;};
/** set receive gain */
double setRxGain(double dB) {if (mRadio) return mRadio->setRxGain(dB); else return -1;}
/** get receive gain */
double getRxGain(void) {if (mRadio) return mRadio->getRxGain(); else return -1;}
/** set transmit frequency */
bool tuneTx(double freq);
/** set receive frequency */
bool tuneRx(double freq);
/** drive transmission of GSM bursts */
void driveTransmitRadio(signalVector &radioBurst, bool zeroBurst);
/** drive reception of GSM bursts */
void driveReceiveRadio();
void setPowerAttenuation(double atten);
/** returns the full-scale transmit amplitude **/
double fullScaleInputValue();
/** returns the full-scale receive amplitude **/
double fullScaleOutputValue();
protected:
/** drive synchronization of Tx/Rx of USRP */
void alignRadio();
/** reset the interface */
void reset();
friend void *AlignRadioServiceLoopAdapter(RadioInterface*);
};
/** synchronization thread loop */
void *AlignRadioServiceLoopAdapter(RadioInterface*);
|
