diff --git a/Transceiver52M/Transceiver.cpp b/Transceiver52M/Transceiver.cpp
index fd6a008..2d4a3cb 100644
--- a/Transceiver52M/Transceiver.cpp
+++ b/Transceiver52M/Transceiver.cpp
@@ -76,142 +76,172 @@
 
 Transceiver::Transceiver(int wBasePort,
 			 const char *TRXAddress,
-			 int wSPS,
+			 size_t wSPS, size_t wChans,
 			 GSM::Time wTransmitLatency,
 			 RadioInterface *wRadioInterface)
   : mBasePort(wBasePort), mAddr(TRXAddress),
-    mDataSocket(NULL), mCtrlSocket(NULL), mClockSocket(NULL),
-    mSPSTx(wSPS), mSPSRx(1), mNoises(NOISE_CNT)
+    mTransmitLatency(wTransmitLatency), mClockSocket(NULL), mRadioInterface(wRadioInterface),
+    mNoiseLev(0.0), mNoises(NOISE_CNT), mSPSTx(wSPS), mSPSRx(1), mChans(wChans),
+    mOn(false), mTxFreq(0.0), mRxFreq(0.0), mPower(-10), mMaxExpectedDelay(0)
 {
   GSM::Time startTime(random() % gHyperframe,0);
 
-  mRxServiceLoopThread = new Thread(32768);
-  mTxServiceLoopThread = new Thread(32768);
-  mControlServiceLoopThread = new Thread(32768);       ///< thread to process control messages from GSM core
-  mTransmitPriorityQueueServiceLoopThread = new Thread(32768);///< thread to process transmit bursts from GSM core
+  mRxLowerLoopThread = new Thread(32768);
+  mTxLowerLoopThread = new Thread(32768);
 
-  mRadioInterface = wRadioInterface;
-  mTransmitLatency = wTransmitLatency;
   mTransmitDeadlineClock = startTime;
   mLastClockUpdateTime = startTime;
   mLatencyUpdateTime = startTime;
   mRadioInterface->getClock()->set(startTime);
-  mMaxExpectedDelay = 0;
 
   txFullScale = mRadioInterface->fullScaleInputValue();
   rxFullScale = mRadioInterface->fullScaleOutputValue();
-
-  mOn = false;
-  mTxFreq = 0.0;
-  mRxFreq = 0.0;
-  mPower = -10;
-  mNoiseLev = 0.0;
 }
 
 Transceiver::~Transceiver()
 {
   sigProcLibDestroy();
-  mTransmitPriorityQueue.clear();
 
   delete mClockSocket;
-  delete mCtrlSocket;
-  delete mDataSocket;
+
+  for (size_t i = 0; i < mChans; i++) {
+    mTxPriorityQueues[i].clear();
+    delete mCtrlSockets[i];
+    delete mDataSockets[i];
+  }
 }
 
 bool Transceiver::init()
 {
   signalVector *burst;
 
+  if (!mChans) {
+    LOG(ALERT) << "No channels assigned";
+    return false;
+  }
+
   if (!sigProcLibSetup(mSPSTx)) {
     LOG(ALERT) << "Failed to initialize signal processing library";
     return false;
   }
 
+  mDataSockets.resize(mChans);
+  mCtrlSockets.resize(mChans);
+
+  mControlServiceLoopThreads.resize(mChans);
+  mTxPriorityQueueServiceLoopThreads.resize(mChans);
+  mRxServiceLoopThreads.resize(mChans);
+
+  mTxPriorityQueues.resize(mChans);
+  mReceiveFIFO.resize(mChans);
+  mStates.resize(mChans);
+
   mClockSocket = new UDPSocket(mBasePort, mAddr.c_str(), mBasePort + 100);
-  mCtrlSocket = new UDPSocket(mBasePort + 1, mAddr.c_str(), mBasePort + 101);
-  mDataSocket = new UDPSocket(mBasePort + 2, mAddr.c_str(), mBasePort + 102);
 
-  for (size_t n = 0; n < 8; n++) {
-    burst = modulateBurst(gDummyBurst, 8 + (n % 4 == 0), mSPSTx);
-    scaleVector(*burst, txFullScale);
-    mState.init(n, burst);
-    mState.chanEstimateTime[n] = mTransmitDeadlineClock;
+  for (size_t i = 0; i < mChans; i++) {
+    mDataSockets[i] = new UDPSocket(mBasePort + 2 * i + 2, mAddr.c_str(),
+                                    mBasePort + 2 * i + 102);
+    mCtrlSockets[i] = new UDPSocket(mBasePort + 2 * i + 1, mAddr.c_str(),
+                                    mBasePort + 2 * i + 101);
+  }
 
-    delete burst;
+  for (size_t i = 0; i < mChans; i++) {
+    mControlServiceLoopThreads[i] = new Thread(32768);
+    mTxPriorityQueueServiceLoopThreads[i] = new Thread(32768);
+    mRxServiceLoopThreads[i] = new Thread(32768);
+
+    for (size_t n = 0; n < 8; n++) {
+      burst = modulateBurst(gDummyBurst, 8 + (n % 4 == 0), mSPSTx);
+      scaleVector(*burst, txFullScale);
+      mStates[i].init(n, burst);
+      delete burst;
+    }
   }
 
   return true;
 }
 
-void Transceiver::addRadioVector(BitVector &burst,
-				 int RSSI,
-				 GSM::Time &wTime)
+void Transceiver::addRadioVector(size_t chan, BitVector &burst,
+                                 int RSSI, GSM::Time &wTime)
 {
+  if (chan >= mTxPriorityQueues.size()) {
+    LOG(ALERT) << "Invalid channel " << chan;
+    return;
+  }
+
   // modulate and stick into queue 
   signalVector* modBurst = modulateBurst(burst,
 					 8 + (wTime.TN() % 4 == 0),
 					 mSPSTx);
   scaleVector(*modBurst,txFullScale * pow(10,-RSSI/10));
   radioVector *newVec = new radioVector(*modBurst,wTime);
-  mTransmitPriorityQueue.write(newVec);
+  mTxPriorityQueues[chan].write(newVec);
 
   delete modBurst;
 }
 
 void Transceiver::pushRadioVector(GSM::Time &nowTime)
 {
+  int TN, modFN;
+  radioVector *burst;
+  TransceiverState *state;
+  std::vector<signalVector *> bursts(mChans);
+  std::vector<bool> zeros(mChans);
 
-  // dump stale bursts, if any
-  while (radioVector* staleBurst = mTransmitPriorityQueue.getStaleBurst(nowTime)) {
-    // Even if the burst is stale, put it in the fillter table.
-    // (It might be an idle pattern.)
-    LOG(NOTICE) << "dumping STALE burst in TRX->USRP interface";
-    const GSM::Time& nextTime = staleBurst->getTime();
-    int TN = nextTime.TN();
-    int modFN = nextTime.FN() % mState.fillerModulus[TN];
-    delete mState.fillerTable[modFN][TN];
-    mState.fillerTable[modFN][TN] = staleBurst;
-  }
-  
-  int TN = nowTime.TN();
-  int modFN = nowTime.FN() % mState.fillerModulus[nowTime.TN()];
+  for (size_t i = 0; i < mChans; i ++) {
+    state = &mStates[i];
 
-  // if queue contains data at the desired timestamp, stick it into FIFO
-  if (radioVector *next = (radioVector*) mTransmitPriorityQueue.getCurrentBurst(nowTime)) {
-    LOG(DEBUG) << "transmitFIFO: wrote burst " << next << " at time: " << nowTime;
-    delete mState.fillerTable[modFN][TN];
-    mState.fillerTable[modFN][TN] = new signalVector(*(next));
-    mRadioInterface->driveTransmitRadio(*(next), mState.chanType[TN] == NONE);
-    delete next;
-    return;
+    while ((burst = mTxPriorityQueues[i].getStaleBurst(nowTime))) {
+      LOG(NOTICE) << "dumping STALE burst in TRX->USRP interface";
+
+      TN = burst->getTime().TN();
+      modFN = burst->getTime().FN() % state->fillerModulus[TN];
+
+      delete state->fillerTable[modFN][TN];
+      state->fillerTable[modFN][TN] = burst;
+    }
+
+    TN = nowTime.TN();
+    modFN = nowTime.FN() % state->fillerModulus[TN];
+
+    bursts[i] = state->fillerTable[modFN][TN];
+    zeros[i] = state->chanType[TN] == NONE;
+
+    if ((burst = mTxPriorityQueues[i].getCurrentBurst(nowTime))) {
+      delete state->fillerTable[modFN][TN];
+      state->fillerTable[modFN][TN] = burst;
+      bursts[i] = burst;
+    }
   }
 
-  // otherwise, pull filler data, and push to radio FIFO
-  mRadioInterface->driveTransmitRadio(*(mState.fillerTable[modFN][TN]),
-                                      mState.chanType[TN]==NONE);
+  mRadioInterface->driveTransmitRadio(bursts, zeros);
+
+  return;
 }
 
-void Transceiver::setModulus(int timeslot)
+void Transceiver::setModulus(size_t timeslot, size_t chan)
 {
-  switch (mState.chanType[timeslot]) {
+  TransceiverState *state = &mStates[chan];
+
+  switch (state->chanType[timeslot]) {
   case NONE:
   case I:
   case II:
   case III:
   case FILL:
-    mState.fillerModulus[timeslot] = 26;
+    state->fillerModulus[timeslot] = 26;
     break;
   case IV:
   case VI:
   case V:
-    mState.fillerModulus[timeslot] = 51;
+    state->fillerModulus[timeslot] = 51;
     break;
     //case V: 
   case VII:
-    mState.fillerModulus[timeslot] = 102;
+    state->fillerModulus[timeslot] = 102;
     break;
   case XIII:
-    mState.fillerModulus[timeslot] = 52;
+    state->fillerModulus[timeslot] = 52;
     break;
   default:
     break;
@@ -219,13 +249,14 @@
 }
 
 
-Transceiver::CorrType Transceiver::expectedCorrType(GSM::Time currTime)
+Transceiver::CorrType Transceiver::expectedCorrType(GSM::Time currTime,
+                                                    size_t chan)
 {
-  
+  TransceiverState *state = &mStates[chan];
   unsigned burstTN = currTime.TN();
   unsigned burstFN = currTime.FN();
 
-  switch (mState.chanType[burstTN]) {
+  switch (state->chanType[burstTN]) {
   case NONE:
     return OFF;
     break;
@@ -287,25 +318,24 @@
     return OFF;
     break;
   }
-
 }
 
-SoftVector *Transceiver::pullRadioVector(GSM::Time &wTime,
-				      int &RSSI,
-				      int &timingOffset)
+SoftVector *Transceiver::pullRadioVector(GSM::Time &wTime, int &RSSI,
+                                         int &timingOffset, size_t chan)
 {
-  bool needDFE = false, success = false, estimateChannel = false;
+  bool needDFE = false;
+  bool success = false;
   complex amp = 0.0;
   float TOA = 0.0, avg = 0.0;
-  signalVector *chanResponse;
+  TransceiverState *state = &mStates[chan];
 
-  radioVector *rxBurst = (radioVector *) mReceiveFIFO->get();
+  radioVector *rxBurst = (radioVector *) mReceiveFIFO[chan]->read();
 
   if (!rxBurst) return NULL;
 
   int timeslot = rxBurst->getTime().TN();
 
-  CorrType corrType = expectedCorrType(rxBurst->getTime());
+  CorrType corrType = expectedCorrType(rxBurst->getTime(), chan);
 
   if ((corrType==OFF) || (corrType==IDLE)) {
     delete rxBurst;
@@ -323,55 +353,58 @@
   // run the proper correlator
   if (corrType==TSC) {
     LOG(DEBUG) << "looking for TSC at time: " << rxBurst->getTime();
-    double framesElapsed = rxBurst->getTime() - mState.chanEstimateTime[timeslot];
-    if ((framesElapsed > 50) || (!mState.chanResponse[timeslot])) {
-      delete mState.chanResponse[timeslot];
-      delete mState.DFEForward[timeslot];
-      delete mState.DFEFeedback[timeslot];
+    signalVector *channelResp;
+    double framesElapsed = rxBurst->getTime() - state->chanEstimateTime[timeslot];
+    bool estimateChannel = false;
+    if ((framesElapsed > 50) || (state->chanResponse[timeslot]==NULL)) {
+	if (state->chanResponse[timeslot])
+          delete state->chanResponse[timeslot];
+        if (state->DFEForward[timeslot])
+          delete state->DFEForward[timeslot];
+        if (state->DFEFeedback[timeslot])
+          delete state->DFEFeedback[timeslot];
 
-      mState.chanResponse[timeslot] = NULL;
-      mState.DFEForward[timeslot] = NULL;
-      mState.DFEFeedback[timeslot] = NULL;
-
-      if (needDFE)
-        estimateChannel = true;
+        state->chanResponse[timeslot] = NULL;
+        state->DFEForward[timeslot] = NULL;
+        state->DFEFeedback[timeslot] = NULL;
+	estimateChannel = true;
     }
-
+    if (!needDFE) estimateChannel = false;
     float chanOffset;
     success = analyzeTrafficBurst(*vectorBurst,
-				  mTSC,
-				  5.0,
-				  mSPSRx,
-				  &amp,
-				  &TOA,
-				  mMaxExpectedDelay, 
-				  estimateChannel,
-				  &chanResponse,
-				  &chanOffset);
+                                  mTSC,
+                                  5.0,
+                                  mSPSRx,
+                                  &amp,
+                                  &TOA,
+                                  mMaxExpectedDelay,
+                                  estimateChannel,
+                                  &channelResp,
+                                  &chanOffset);
     if (success) {
-      mState.SNRestimate[timeslot] = amp.norm2() / (mNoiseLev * mNoiseLev+1.0);
+      state->SNRestimate[timeslot] = amp.norm2() / (mNoiseLev * mNoiseLev + 1.0);
+
       if (estimateChannel) {
-         mState.chanResponse[timeslot] = chanResponse;
-       	 mState.chanRespOffset[timeslot] = chanOffset;
-         mState.chanRespAmplitude[timeslot] = amp;
-	 scaleVector(*chanResponse, complex(1.0,0.0) / amp);
+         state->chanResponse[timeslot] = channelResp;
+         state->chanRespOffset[timeslot] = chanOffset;
+         state->chanRespAmplitude[timeslot] = amp;
+	 scaleVector(*channelResp, complex(1.0, 0.0) / amp);
+         designDFE(*channelResp, state->SNRestimate[timeslot],
+                   7, &state->DFEForward[timeslot],
+                   &state->DFEFeedback[timeslot]);
 
-         designDFE(*chanResponse, mState.SNRestimate[timeslot], 7,
-                   &mState.DFEForward[timeslot],
-                   &mState.DFEFeedback[timeslot]);
-
-         mState.chanEstimateTime[timeslot] = rxBurst->getTime();
+         state->chanEstimateTime[timeslot] = rxBurst->getTime();
       }
     }
     else {
-      mState.chanResponse[timeslot] = NULL;
+      state->chanResponse[timeslot] = NULL;
       mNoises.insert(avg);
     }
   }
   else {
     // RACH burst
-    if (success = detectRACHBurst(*vectorBurst, 6.0, mSPSRx, &amp, &TOA))
-      mState.chanResponse[timeslot] = NULL;
+    if ((success = detectRACHBurst(*vectorBurst, 6.0, mSPSRx, &amp, &TOA)))
+      state->chanResponse[timeslot] = NULL;
     else
       mNoises.insert(avg);
   }
@@ -382,12 +415,12 @@
     if ((corrType==RACH) || (!needDFE)) {
       burst = demodulateBurst(*vectorBurst, mSPSRx, amp, TOA);
     } else {
-      scaleVector(*vectorBurst,complex(1.0,0.0) / amp);
+      scaleVector(*vectorBurst, complex(1.0, 0.0) / amp);
       burst = equalizeBurst(*vectorBurst,
-                            TOA - mState.chanRespOffset[timeslot],
-                            mSPSRx,
-                            *mState.DFEForward[timeslot],
-                            *mState.DFEFeedback[timeslot]);
+			    TOA - state->chanRespOffset[timeslot],
+			    mSPSRx,
+			    *state->DFEForward[timeslot],
+			    *state->DFEFeedback[timeslot]);
     }
     wTime = rxBurst->getTime();
     RSSI = (int) floor(20.0*log10(rxFullScale/avg));
@@ -395,8 +428,6 @@
     timingOffset = (int) round(TOA * 256.0 / mSPSRx);
   }
 
-  //if (burst) LOG(DEBUG) << "burst: " << *burst << '\n';
-
   delete rxBurst;
 
   return burst;
@@ -404,20 +435,24 @@
 
 void Transceiver::start()
 {
-  mControlServiceLoopThread->start((void * (*)(void*))ControlServiceLoopAdapter,(void*) this);
+  TransceiverChannel *chan;
+
+  for (size_t i = 0; i < mControlServiceLoopThreads.size(); i++) {
+    chan = new TransceiverChannel(this, i);
+    mControlServiceLoopThreads[i]->start((void * (*)(void*))
+                                 ControlServiceLoopAdapter, (void*) chan);
+  }
 }
 
 void Transceiver::reset()
 {
-  mTransmitPriorityQueue.clear();
-  //mTransmitFIFO->clear();
-  //mReceiveFIFO->clear();
+  for (size_t i = 0; i < mTxPriorityQueues.size(); i++)
+    mTxPriorityQueues[i].clear();
 }
 
   
-void Transceiver::driveControl()
+void Transceiver::driveControl(size_t chan)
 {
-
   int MAX_PACKET_LENGTH = 100;
 
   // check control socket
@@ -425,7 +460,7 @@
   int msgLen = -1;
   buffer[0] = '\0';
 
-  msgLen = mCtrlSocket->read(buffer);
+  msgLen = mCtrlSockets[chan]->read(buffer);
 
   if (msgLen < 1) {
     return;
@@ -436,8 +471,9 @@
   char response[MAX_PACKET_LENGTH];
 
   sscanf(buffer,"%3s %s",cmdcheck,command);
- 
-  writeClockInterface();
+
+  if (!chan)
+    writeClockInterface();
 
   if (strcmp(cmdcheck,"CMD")!=0) {
     LOG(WARNING) << "bogus message on control interface";
@@ -455,17 +491,28 @@
       sprintf(response,"RSP POWERON 1");
     else {
       sprintf(response,"RSP POWERON 0");
-      if (!mOn) {
+      if (!chan && !mOn) {
         // Prepare for thread start
         mPower = -20;
         mRadioInterface->start();
 
         // Start radio interface threads.
-        mTxServiceLoopThread->start((void * (*)(void*))TxServiceLoopAdapter,(void*) this);
-        mRxServiceLoopThread->start((void * (*)(void*))RxServiceLoopAdapter,(void*) this);
-        mTransmitPriorityQueueServiceLoopThread->start((void * (*)(void*))TransmitPriorityQueueServiceLoopAdapter,(void*) this);
-        writeClockInterface();
+        mTxLowerLoopThread->start((void * (*)(void*))
+                                  TxLowerLoopAdapter,(void*) this);
+        mRxLowerLoopThread->start((void * (*)(void*))
+                                  RxLowerLoopAdapter,(void*) this);
 
+        for (size_t i = 0; i < mChans; i++) {
+          TransceiverChannel *chan = new TransceiverChannel(this, i);
+          mRxServiceLoopThreads[i]->start((void * (*)(void*))
+                                  RxUpperLoopAdapter, (void*) chan);
+
+          chan = new TransceiverChannel(this, i);
+          mTxPriorityQueueServiceLoopThreads[i]->start((void * (*)(void*))
+                                  TxUpperLoopAdapter, (void*) chan);
+        }
+
+        writeClockInterface();
         mOn = true;
       }
     }
@@ -481,7 +528,7 @@
     //set expected maximum time-of-arrival
     int newGain;
     sscanf(buffer,"%3s %s %d",cmdcheck,command,&newGain);
-    newGain = mRadioInterface->setRxGain(newGain);
+    newGain = mRadioInterface->setRxGain(newGain, chan);
     sprintf(response,"RSP SETRXGAIN 0 %d",newGain);
   }
   else if (strcmp(command,"NOISELEV")==0) {
@@ -501,7 +548,7 @@
       sprintf(response,"RSP SETPOWER 1 %d",dbPwr);
     else {
       mPower = dbPwr;
-      mRadioInterface->setPowerAttenuation(dbPwr);
+      mRadioInterface->setPowerAttenuation(dbPwr, chan);
       sprintf(response,"RSP SETPOWER 0 %d",dbPwr);
     }
   }
@@ -522,7 +569,7 @@
     int freqKhz;
     sscanf(buffer,"%3s %s %d",cmdcheck,command,&freqKhz);
     mRxFreq = freqKhz*1.0e3+FREQOFFSET;
-    if (!mRadioInterface->tuneRx(mRxFreq)) {
+    if (!mRadioInterface->tuneRx(mRxFreq, chan)) {
        LOG(ALERT) << "RX failed to tune";
        sprintf(response,"RSP RXTUNE 1 %d",freqKhz);
     }
@@ -535,7 +582,7 @@
     sscanf(buffer,"%3s %s %d",cmdcheck,command,&freqKhz);
     //freqKhz = 890e3;
     mTxFreq = freqKhz*1.0e3+FREQOFFSET;
-    if (!mRadioInterface->tuneTx(mTxFreq)) {
+    if (!mRadioInterface->tuneTx(mTxFreq, chan)) {
        LOG(ALERT) << "TX failed to tune";
        sprintf(response,"RSP TXTUNE 1 %d",freqKhz);
     }
@@ -564,8 +611,8 @@
       sprintf(response,"RSP SETSLOT 1 %d %d",timeslot,corrCode);
       return;
     }     
-    mState.chanType[timeslot] = corrCode;
-    setModulus(timeslot);
+    mStates[chan].chanType[timeslot] = (ChannelCombination) corrCode;
+    setModulus(timeslot, chan);
     sprintf(response,"RSP SETSLOT 0 %d %d",timeslot,corrCode);
 
   }
@@ -573,16 +620,15 @@
     LOG(WARNING) << "bogus command " << command << " on control interface.";
   }
 
-  mCtrlSocket->write(response, strlen(response) + 1);
+  mCtrlSockets[chan]->write(response, strlen(response) + 1);
 }
 
-bool Transceiver::driveTransmitPriorityQueue() 
+bool Transceiver::driveTxPriorityQueue(size_t chan)
 {
-
   char buffer[gSlotLen+50];
 
   // check data socket
-  size_t msgLen = mDataSocket->read(buffer);
+  size_t msgLen = mDataSockets[chan]->read(buffer);
 
   if (msgLen!=gSlotLen+1+4+1) {
     LOG(ERR) << "badly formatted packet on GSM->TRX interface";
@@ -613,9 +659,11 @@
   // periodically update GSM core clock
   LOG(DEBUG) << "mTransmitDeadlineClock " << mTransmitDeadlineClock
 		<< " mLastClockUpdateTime " << mLastClockUpdateTime;
-  if (mTransmitDeadlineClock > mLastClockUpdateTime + GSM::Time(216,0))
-    writeClockInterface();
 
+  if (!chan) {
+    if (mTransmitDeadlineClock > mLastClockUpdateTime + GSM::Time(216,0))
+      writeClockInterface();
+  }
 
   LOG(DEBUG) << "rcvd. burst at: " << GSM::Time(frameNum,timeSlot);
   
@@ -627,27 +675,28 @@
     *itr++ = *bufferItr++;
   
   GSM::Time currTime = GSM::Time(frameNum,timeSlot);
-  
-  addRadioVector(newBurst,RSSI,currTime);
-  
-  LOG(DEBUG) "added burst - time: " << currTime << ", RSSI: " << RSSI; // << ", data: " << newBurst; 
+
+  addRadioVector(chan, newBurst, RSSI, currTime);
 
   return true;
 
 
 }
- 
-void Transceiver::driveReceiveFIFO() 
-{
 
+void Transceiver::driveReceiveRadio()
+{
+  if (!mRadioInterface->driveReceiveRadio())
+    usleep(100000);
+}
+
+void Transceiver::driveReceiveFIFO(size_t chan)
+{
   SoftVector *rxBurst = NULL;
   int RSSI;
   int TOA;  // in 1/256 of a symbol
   GSM::Time burstTime;
 
-  mRadioInterface->driveReceiveRadio();
-
-  rxBurst = pullRadioVector(burstTime,RSSI,TOA);
+  rxBurst = pullRadioVector(burstTime, RSSI, TOA, chan);
 
   if (rxBurst) { 
 
@@ -672,11 +721,11 @@
     burstString[gSlotLen+9] = '\0';
     delete rxBurst;
 
-    mDataSocket->write(burstString, gSlotLen + 10);
+    mDataSockets[chan]->write(burstString,gSlotLen+10);
   }
 }
 
-void Transceiver::driveTransmitFIFO() 
+void Transceiver::driveTxFIFO()
 {
 
   /**
@@ -744,46 +793,70 @@
 
 }
 
-void *RxServiceLoopAdapter(Transceiver *transceiver)
+void *RxUpperLoopAdapter(TransceiverChannel *chan)
+{
+  Transceiver *trx = chan->trx;
+  size_t num = chan->num;
+
+  delete chan;
+
+  while (1) {
+    trx->driveReceiveFIFO(num);
+    pthread_testcancel();
+  }
+  return NULL;
+}
+
+void *RxLowerLoopAdapter(Transceiver *transceiver)
 {
   transceiver->setPriority();
 
   while (1) {
-    transceiver->driveReceiveFIFO();
+    transceiver->driveReceiveRadio();
     pthread_testcancel();
   }
   return NULL;
 }
 
-void *TxServiceLoopAdapter(Transceiver *transceiver)
+void *TxLowerLoopAdapter(Transceiver *transceiver)
 {
   while (1) {
-    transceiver->driveTransmitFIFO();
+    transceiver->driveTxFIFO();
     pthread_testcancel();
   }
   return NULL;
 }
 
-void *ControlServiceLoopAdapter(Transceiver *transceiver)
+void *ControlServiceLoopAdapter(TransceiverChannel *chan)
 {
+  Transceiver *trx = chan->trx;
+  size_t num = chan->num;
+
+  delete chan;
+
   while (1) {
-    transceiver->driveControl();
+    trx->driveControl(num);
     pthread_testcancel();
   }
   return NULL;
 }
 
-void *TransmitPriorityQueueServiceLoopAdapter(Transceiver *transceiver)
+void *TxUpperLoopAdapter(TransceiverChannel *chan)
 {
+  Transceiver *trx = chan->trx;
+  size_t num = chan->num;
+
+  delete chan;
+
   while (1) {
     bool stale = false;
     // Flush the UDP packets until a successful transfer.
-    while (!transceiver->driveTransmitPriorityQueue()) {
-      stale = true; 
+    while (!trx->driveTxPriorityQueue(num)) {
+      stale = true;
     }
-    if (stale) {
+    if (!num && stale) {
       // If a packet was stale, remind the GSM stack of the clock.
-      transceiver->writeClockInterface();
+      trx->writeClockInterface();
     }
     pthread_testcancel();
   }
diff --git a/Transceiver52M/Transceiver.h b/Transceiver52M/Transceiver.h
index 1f8bed2..4356ef2 100644
--- a/Transceiver52M/Transceiver.h
+++ b/Transceiver52M/Transceiver.h
@@ -86,18 +86,18 @@
   GSM::Time mTransmitLatency;     ///< latency between basestation clock and transmit deadline clock
   GSM::Time mLatencyUpdateTime;   ///< last time latency was updated
 
-  UDPSocket *mDataSocket;         ///< socket for writing to/reading from GSM core
-  UDPSocket *mCtrlSocket;         ///< socket for writing/reading control commands from GSM core
-  UDPSocket *mClockSocket;        ///< socket for writing clock updates to GSM core
+  std::vector<UDPSocket *> mDataSockets;  ///< socket for writing to/reading from GSM core
+  std::vector<UDPSocket *> mCtrlSockets;  ///< socket for writing/reading control commands from GSM core
+  UDPSocket *mClockSocket;                ///< socket for writing clock updates to GSM core
 
-  VectorQueue  mTransmitPriorityQueue;   ///< priority queue of transmit bursts received from GSM core
-  VectorFIFO*  mTransmitFIFO;     ///< radioInterface FIFO of transmit bursts 
-  VectorFIFO*  mReceiveFIFO;      ///< radioInterface FIFO of receive bursts 
+  std::vector<VectorQueue> mTxPriorityQueues;   ///< priority queue of transmit bursts received from GSM core
+  std::vector<VectorFIFO *>  mReceiveFIFO;      ///< radioInterface FIFO of receive bursts
 
-  Thread *mRxServiceLoopThread;   ///< thread to pull bursts into receive FIFO
-  Thread *mTxServiceLoopThread;   ///< thread to push bursts into transmit FIFO
-  Thread *mControlServiceLoopThread;       ///< thread to process control messages from GSM core
-  Thread *mTransmitPriorityQueueServiceLoopThread;///< thread to process transmit bursts from GSM core
+  std::vector<Thread *> mRxServiceLoopThreads;  ///< thread to pull bursts into receive FIFO
+  Thread *mRxLowerLoopThread;                   ///< thread to pull bursts into receive FIFO
+  Thread *mTxLowerLoopThread;                   ///< thread to push bursts into transmit FIFO
+  std::vector<Thread *> mControlServiceLoopThreads;         ///< thread to process control messages from GSM core
+  std::vector<Thread *> mTxPriorityQueueServiceLoopThreads; ///< thread to process transmit bursts from GSM core
 
   GSM::Time mTransmitDeadlineClock;       ///< deadline for pushing bursts into transmit FIFO 
   GSM::Time mLastClockUpdateTime;         ///< last time clock update was sent up to core
@@ -118,29 +118,28 @@
   noiseVector mNoises;  ///< Vector holding running noise measurements
 
   /** modulate and add a burst to the transmit queue */
-  void addRadioVector(BitVector &burst,
-		      int RSSI,
-		      GSM::Time &wTime);
+  void addRadioVector(size_t chan, BitVector &burst,
+                      int RSSI, GSM::Time &wTime);
 
   /** Push modulated burst into transmit FIFO corresponding to a particular timestamp */
   void pushRadioVector(GSM::Time &nowTime);
 
-  /** Pull and demodulate a burst from the receive FIFO */ 
-  SoftVector *pullRadioVector(GSM::Time &wTime,
-			   int &RSSI,
-			   int &timingOffset);
-   
+  /** Pull and demodulate a burst from the receive FIFO */
+  SoftVector *pullRadioVector(GSM::Time &wTime, int &RSSI,
+                              int &timingOffset, size_t chan = 0);
+
   /** Set modulus for specific timeslot */
-  void setModulus(int timeslot);
+  void setModulus(size_t timeslot, size_t chan);
 
   /** return the expected burst type for the specified timestamp */
-  CorrType expectedCorrType(GSM::Time currTime);
+  CorrType expectedCorrType(GSM::Time currTime, size_t chan);
 
   /** send messages over the clock socket */
   void writeClockInterface(void);
 
   int mSPSTx;                          ///< number of samples per Tx symbol
   int mSPSRx;                          ///< number of samples per Rx symbol
+  size_t mChans;
 
   bool mOn;			       ///< flag to indicate that transceiver is powered on
   double mTxFreq;                      ///< the transmit frequency
@@ -149,7 +148,7 @@
   unsigned mTSC;                       ///< the midamble sequence code
   unsigned mMaxExpectedDelay;            ///< maximum expected time-of-arrival offset in GSM symbols
 
-  TransceiverState mState;
+  std::vector<TransceiverState> mStates;
 
 public:
 
@@ -162,10 +161,10 @@
   */
   Transceiver(int wBasePort,
 	      const char *TRXAddress,
-	      int wSPS,
+	      size_t wSPS, size_t chans,
 	      GSM::Time wTransmitLatency,
 	      RadioInterface *wRadioInterface);
-   
+
   /** Destructor */
   ~Transceiver();
 
@@ -174,10 +173,14 @@
   bool init();
 
   /** attach the radioInterface receive FIFO */
-  void receiveFIFO(VectorFIFO *wFIFO) { mReceiveFIFO = wFIFO;}
+  bool receiveFIFO(VectorFIFO *wFIFO, size_t chan)
+  {
+    if (chan >= mReceiveFIFO.size())
+      return false;
 
-  /** attach the radioInterface transmit FIFO */
-  void transmitFIFO(VectorFIFO *wFIFO) { mTransmitFIFO = wFIFO;}
+    mReceiveFIFO[chan] = wFIFO;
+    return true;
+  }
 
   /** Codes for channel combinations */
   typedef enum {
@@ -200,29 +203,34 @@
   } ChannelCombination;
 
 protected:
+  /** drive lower receive I/O and burst generation */
+  void driveReceiveRadio();
 
-  /** drive reception and demodulation of GSM bursts */ 
-  void driveReceiveFIFO();
+  /** drive demodulation of GSM bursts */
+  void driveReceiveFIFO(size_t chan);
 
   /** drive transmission of GSM bursts */
-  void driveTransmitFIFO();
+  void driveTxFIFO();
 
   /** drive handling of control messages from GSM core */
-  void driveControl();
+  void driveControl(size_t chan);
 
   /**
     drive modulation and sorting of GSM bursts from GSM core
     @return true if a burst was transferred successfully
   */
-  bool driveTransmitPriorityQueue();
+  bool driveTxPriorityQueue(size_t chan);
 
-  friend void *RxServiceLoopAdapter(Transceiver *);
+  friend void *RxUpperLoopAdapter(TransceiverChannel *);
 
-  friend void *TxServiceLoopAdapter(Transceiver *);
+  friend void *TxUpperLoopAdapter(TransceiverChannel *);
 
-  friend void *ControlServiceLoopAdapter(Transceiver *);
+  friend void *RxLowerLoopAdapter(Transceiver *);
 
-  friend void *TransmitPriorityQueueServiceLoopAdapter(Transceiver *);
+  friend void *TxLowerLoopAdapter(Transceiver *);
+
+  friend void *ControlServiceLoopAdapter(TransceiverChannel *);
+
 
   void reset();
 
@@ -231,13 +239,15 @@
 
 };
 
+void *RxUpperLoopAdapter(TransceiverChannel *);
+
 /** Main drive threads */
-void *RxServiceLoopAdapter(Transceiver *);
-void *TxServiceLoopAdapter(Transceiver *);
+void *RxLowerLoopAdapter(Transceiver *);
+void *TxLowerLoopAdapter(Transceiver *);
 
 /** control message handler thread loop */
-void *ControlServiceLoopAdapter(Transceiver *);
+void *ControlServiceLoopAdapter(TransceiverChannel *);
 
 /** transmit queueing thread loop */
-void *TransmitPriorityQueueServiceLoopAdapter(Transceiver *);
+void *TxUpperLoopAdapter(TransceiverChannel *);
 
diff --git a/Transceiver52M/UHDDevice.cpp b/Transceiver52M/UHDDevice.cpp
index 7a1a74d..224ebd0 100644
--- a/Transceiver52M/UHDDevice.cpp
+++ b/Transceiver52M/UHDDevice.cpp
@@ -211,7 +211,7 @@
 */
 class uhd_device : public RadioDevice {
 public:
-	uhd_device(int sps, bool skip_rx);
+	uhd_device(size_t sps, size_t chans);
 	~uhd_device();
 
 	int open(const std::string &args, bool extref);
@@ -221,16 +221,16 @@
 	void setPriority();
 	enum TxWindowType getWindowType() { return tx_window; }
 
-	int readSamples(short *buf, int len, bool *overrun, 
+	int readSamples(std::vector<short *> &bufs, int len, bool *overrun,
 			TIMESTAMP timestamp, bool *underrun, unsigned *RSSI);
 
-	int writeSamples(short *buf, int len, bool *underrun, 
+	int writeSamples(std::vector<short *> &bufs, int len, bool *underrun,
 			 TIMESTAMP timestamp, bool isControl);
 
 	bool updateAlignment(TIMESTAMP timestamp);
 
-	bool setTxFreq(double wFreq);
-	bool setRxFreq(double wFreq);
+	bool setTxFreq(double wFreq, size_t chan);
+	bool setRxFreq(double wFreq, size_t chan);
 
 	inline TIMESTAMP initialWriteTimestamp() { return 0; }
 	inline TIMESTAMP initialReadTimestamp() { return 0; }
@@ -238,17 +238,18 @@
 	inline double fullScaleInputValue() { return 32000 * TX_AMPL; }
 	inline double fullScaleOutputValue() { return 32000; }
 
-	double setRxGain(double db);
-	double getRxGain(void) { return rx_gain; }
+	double setRxGain(double db, size_t chan);
+	double getRxGain(size_t chan);
 	double maxRxGain(void) { return rx_gain_max; }
 	double minRxGain(void) { return rx_gain_min; }
 
-	double setTxGain(double db);
+	double setTxGain(double db, size_t chan);
 	double maxTxGain(void) { return tx_gain_max; }
 	double minTxGain(void) { return tx_gain_min; }
 
-	double getTxFreq() { return tx_freq; }
-	double getRxFreq() { return rx_freq; }
+	double getTxFreq(size_t chan);
+	double getRxFreq(size_t chan);
+	double getRxFreq();
 
 	inline double getSampleRate() { return tx_rate; }
 	inline double numberRead() { return rx_pkt_cnt; }
@@ -272,25 +273,25 @@
 	enum TxWindowType tx_window;
 	enum uhd_dev_type dev_type;
 
-	int sps;
+	size_t sps, chans;
 	double tx_rate, rx_rate;
 
-	double tx_gain, tx_gain_min, tx_gain_max;
-	double rx_gain, rx_gain_min, rx_gain_max;
+	double tx_gain_min, tx_gain_max;
+	double rx_gain_min, rx_gain_max;
 
-	double tx_freq, rx_freq;
+	std::vector<double> tx_gains, rx_gains;
+	std::vector<double> tx_freqs, rx_freqs;
 	size_t tx_spp, rx_spp;
 
 	bool started;
 	bool aligned;
-	bool skip_rx;
 
 	size_t rx_pkt_cnt;
 	size_t drop_cnt;
 	uhd::time_spec_t prev_ts;
 
 	TIMESTAMP ts_offset;
-	smpl_buf *rx_smpl_buf;
+	std::vector<smpl_buf *> rx_buffers;
 
 	void init_gains();
 	int set_master_clk(double rate);
@@ -335,23 +336,23 @@
 	}
 }
 
-uhd_device::uhd_device(int sps, bool skip_rx)
-	: tx_gain(0.0), tx_gain_min(0.0), tx_gain_max(0.0),
-	  rx_gain(0.0), rx_gain_min(0.0), rx_gain_max(0.0),
-	  tx_freq(0.0), rx_freq(0.0), tx_spp(0), rx_spp(0),
+uhd_device::uhd_device(size_t sps, size_t chans)
+	: tx_gain_min(0.0), tx_gain_max(0.0),
+	  rx_gain_min(0.0), rx_gain_max(0.0),
+	  tx_spp(0), rx_spp(0),
 	  started(false), aligned(false), rx_pkt_cnt(0), drop_cnt(0),
-	  prev_ts(0,0), ts_offset(0), rx_smpl_buf(NULL)
+	  prev_ts(0,0), ts_offset(0)
 {
 	this->sps = sps;
-	this->skip_rx = skip_rx;
+	this->chans = chans;
 }
 
 uhd_device::~uhd_device()
 {
 	stop();
 
-	if (rx_smpl_buf)
-		delete rx_smpl_buf;
+	for (size_t i = 0; i < rx_buffers.size(); i++)
+		delete rx_buffers[i];
 }
 
 void uhd_device::init_gains()
@@ -366,13 +367,18 @@
 	rx_gain_min = range.start();
 	rx_gain_max = range.stop();
 
-	usrp_dev->set_tx_gain((tx_gain_min + tx_gain_max) / 2);
-	usrp_dev->set_rx_gain((rx_gain_min + rx_gain_max) / 2);
+	for (size_t i = 0; i < tx_gains.size(); i++) {
+		usrp_dev->set_tx_gain((tx_gain_min + tx_gain_max) / 2, i);
+		tx_gains[i] = usrp_dev->get_tx_gain(i);
+	}
 
-	tx_gain = usrp_dev->get_tx_gain();
-	rx_gain = usrp_dev->get_rx_gain();
+	for (size_t i = 0; i < rx_gains.size(); i++) {
+		usrp_dev->set_rx_gain((rx_gain_min + rx_gain_max) / 2, i);
+		rx_gains[i] = usrp_dev->get_rx_gain(i);
+	}
 
 	return;
+
 }
 
 int uhd_device::set_master_clk(double clk_rate)
@@ -435,24 +441,44 @@
 	return 0;
 }
 
-double uhd_device::setTxGain(double db)
+double uhd_device::setTxGain(double db, size_t chan)
 {
-	usrp_dev->set_tx_gain(db);
-	tx_gain = usrp_dev->get_tx_gain();
+	if (chan >= tx_gains.size()) {
+		LOG(ALERT) << "Requested non-existent channel" << chan;
+		return 0.0f;
+	}
 
-	LOG(INFO) << "Set TX gain to " << tx_gain << "dB";
+	usrp_dev->set_tx_gain(db, chan);
+	tx_gains[chan] = usrp_dev->get_tx_gain(chan);
 
-	return tx_gain;
+	LOG(INFO) << "Set TX gain to " << tx_gains[chan] << "dB";
+
+	return tx_gains[chan];
 }
 
-double uhd_device::setRxGain(double db)
+double uhd_device::setRxGain(double db, size_t chan)
 {
-	usrp_dev->set_rx_gain(db);
-	rx_gain = usrp_dev->get_rx_gain();
+	if (chan >= rx_gains.size()) {
+		LOG(ALERT) << "Requested non-existent channel " << chan;
+		return 0.0f;
+	}
 
-	LOG(INFO) << "Set RX gain to " << rx_gain << "dB";
+	usrp_dev->set_rx_gain(db, chan);
+	rx_gains[chan] = usrp_dev->get_rx_gain(chan);
 
-	return rx_gain;
+	LOG(INFO) << "Set RX gain to " << rx_gains[chan] << "dB";
+
+	return rx_gains[chan];
+}
+
+double uhd_device::getRxGain(size_t chan)
+{
+	if (chan >= rx_gains.size()) {
+		LOG(ALERT) << "Requested non-existent channel " << chan;
+		return 0.0f;
+	}
+
+	return rx_gains[chan];
 }
 
 /*
@@ -533,11 +559,30 @@
 	if (!parse_dev_type())
 		return -1;
 
+	// Verify and set channels
+	if ((dev_type == UMTRX) && (chans == 2)) {
+		uhd::usrp::subdev_spec_t subdev_spec("A:0 B:0");
+		usrp_dev->set_tx_subdev_spec(subdev_spec);
+		usrp_dev->set_rx_subdev_spec(subdev_spec);
+	} else if (chans != 1) {
+		LOG(ALERT) << "Invalid channel combination for device";
+		return -1;
+	}
+
+	tx_freqs.resize(chans);
+	rx_freqs.resize(chans);
+	tx_gains.resize(chans);
+	rx_gains.resize(chans);
+	rx_buffers.resize(chans);
+
 	if (extref)
 		usrp_dev->set_clock_source("external");
 
 	// Create TX and RX streamers
 	uhd::stream_args_t stream_args("sc16");
+	for (size_t i = 0; i < chans; i++)
+		stream_args.channels.push_back(i);
+
 	tx_stream = usrp_dev->get_tx_stream(stream_args);
 	rx_stream = usrp_dev->get_rx_stream(stream_args);
 
@@ -553,7 +598,8 @@
 
 	// Create receive buffer
 	size_t buf_len = SAMPLE_BUF_SZ / sizeof(uint32_t);
-	rx_smpl_buf = new smpl_buf(buf_len, rx_rate);
+	for (size_t i = 0; i < rx_buffers.size(); i++)
+		rx_buffers[i] = new smpl_buf(buf_len, rx_rate);
 
 	// Set receive chain sample offset 
 	double offset = get_dev_offset(dev_type, sps);
@@ -608,16 +654,13 @@
 
 void uhd_device::restart(uhd::time_spec_t ts)
 {
-	uhd::stream_cmd_t cmd = uhd::stream_cmd_t::STREAM_MODE_STOP_CONTINUOUS;
-	usrp_dev->issue_stream_cmd(cmd);
-
-	flush_recv(50);
-
 	usrp_dev->set_time_now(ts);
 	aligned = false;
 
-	cmd = uhd::stream_cmd_t::STREAM_MODE_START_CONTINUOUS;
-	cmd.stream_now = true;
+	uhd::stream_cmd_t cmd = uhd::stream_cmd_t::STREAM_MODE_START_CONTINUOUS;
+	cmd.time_spec = uhd::time_spec_t(0.1);
+	cmd.stream_now = false;
+
 	usrp_dev->issue_stream_cmd(cmd);
 }
 
@@ -707,16 +750,17 @@
 	return 0;
 }
 
-int uhd_device::readSamples(short *buf, int len, bool *overrun,
-			TIMESTAMP timestamp, bool *underrun, unsigned *RSSI)
+int uhd_device::readSamples(std::vector<short *> &bufs, int len, bool *overrun,
+			    TIMESTAMP timestamp, bool *underrun, unsigned *RSSI)
 {
 	ssize_t rc;
 	uhd::time_spec_t ts;
 	uhd::rx_metadata_t metadata;
-	uint32_t pkt_buf[rx_spp];
 
-	if (skip_rx)
-		return 0;
+	if (bufs.size() != chans) {
+		LOG(ALERT) << "Invalid channel combination " << bufs.size();
+		return -1;
+	}
 
 	*overrun = false;
 	*underrun = false;
@@ -728,21 +772,25 @@
 	LOG(DEBUG) << "Requested timestamp = " << ts.get_real_secs();
 
 	// Check that timestamp is valid
-	rc = rx_smpl_buf->avail_smpls(timestamp);
+	rc = rx_buffers[0]->avail_smpls(timestamp);
 	if (rc < 0) {
-		LOG(ERR) << rx_smpl_buf->str_code(rc);
-		LOG(ERR) << rx_smpl_buf->str_status();
+		LOG(ERR) << rx_buffers[0]->str_code(rc);
+		LOG(ERR) << rx_buffers[0]->str_status();
 		return 0;
 	}
 
+	// Create vector buffer
+	std::vector<std::vector<short> >
+		pkt_bufs(chans, std::vector<short>(2 * rx_spp));
+
+	std::vector<short *> pkt_ptrs;
+	for (size_t i = 0; i < pkt_bufs.size(); i++)
+		pkt_ptrs.push_back(&pkt_bufs[i].front());
+
 	// Receive samples from the usrp until we have enough
-	while (rx_smpl_buf->avail_smpls(timestamp) < len) {
-		size_t num_smpls = rx_stream->recv(
-					(void*)pkt_buf,
-					rx_spp,
-					metadata,
-					0.1,
-					true);
+	while (rx_buffers[0]->avail_smpls(timestamp) < len) {
+		size_t num_smpls = rx_stream->recv(pkt_ptrs, rx_spp,
+						   metadata, 0.1, true);
 		rx_pkt_cnt++;
 
 		// Check for errors 
@@ -758,36 +806,39 @@
 			continue;
 		}
 
-
 		ts = metadata.time_spec;
 		LOG(DEBUG) << "Received timestamp = " << ts.get_real_secs();
 
-		rc = rx_smpl_buf->write(pkt_buf,
-					num_smpls,
-					metadata.time_spec);
+		for (size_t i = 0; i < rx_buffers.size(); i++) {
+			rc = rx_buffers[i]->write((short *) &pkt_bufs[i].front(),
+						  num_smpls,
+						  metadata.time_spec);
 
-		// Continue on local overrun, exit on other errors
-		if ((rc < 0)) {
-			LOG(ERR) << rx_smpl_buf->str_code(rc);
-			LOG(ERR) << rx_smpl_buf->str_status();
-			if (rc != smpl_buf::ERROR_OVERFLOW)
-				return 0;
+			// Continue on local overrun, exit on other errors
+			if ((rc < 0)) {
+				LOG(ERR) << rx_buffers[i]->str_code(rc);
+				LOG(ERR) << rx_buffers[i]->str_status();
+				if (rc != smpl_buf::ERROR_OVERFLOW)
+					return 0;
+			}
 		}
 	}
 
 	// We have enough samples
-	rc = rx_smpl_buf->read(buf, len, timestamp);
-	if ((rc < 0) || (rc != len)) {
-		LOG(ERR) << rx_smpl_buf->str_code(rc);
-		LOG(ERR) << rx_smpl_buf->str_status();
-		return 0;
+	for (size_t i = 0; i < rx_buffers.size(); i++) {
+		rc = rx_buffers[i]->read(bufs[i], len, timestamp);
+		if ((rc < 0) || (rc != len)) {
+			LOG(ERR) << rx_buffers[i]->str_code(rc);
+			LOG(ERR) << rx_buffers[i]->str_status();
+			return 0;
+		}
 	}
 
 	return len;
 }
 
-int uhd_device::writeSamples(short *buf, int len, bool *underrun,
-			unsigned long long timestamp,bool isControl)
+int uhd_device::writeSamples(std::vector<short *> &bufs, int len, bool *underrun,
+			     unsigned long long timestamp,bool isControl)
 {
 	uhd::tx_metadata_t metadata;
 	metadata.has_time_spec = true;
@@ -803,6 +854,11 @@
 		return 0;
 	}
 
+	if (bufs.size() != chans) {
+		LOG(ALERT) << "Invalid channel combination " << bufs.size();
+		return -1;
+	}
+
 	// Drop a fixed number of packets (magic value)
 	if (!aligned) {
 		drop_cnt++;
@@ -822,8 +878,7 @@
 		}
 	}
 
-	size_t num_smpls = tx_stream->send(buf, len, metadata);
-
+	size_t num_smpls = tx_stream->send(bufs, len, metadata);
 	if (num_smpls != (unsigned) len) {
 		LOG(ALERT) << "UHD: Device send timed out";
 		LOG(ALERT) << "UHD: Version " << uhd::get_version_string();
@@ -839,24 +894,54 @@
 	return true;
 }
 
-bool uhd_device::setTxFreq(double wFreq)
+bool uhd_device::setTxFreq(double wFreq, size_t chan)
 {
-	uhd::tune_result_t tr = usrp_dev->set_tx_freq(wFreq);
+	if (chan >= tx_freqs.size()) {
+		LOG(ALERT) << "Requested non-existent channel " << chan;
+		return false;
+	}
+
+	uhd::tune_result_t tr = usrp_dev->set_tx_freq(wFreq, chan);
 	LOG(INFO) << "\n" << tr.to_pp_string();
-	tx_freq = usrp_dev->get_tx_freq();
+	tx_freqs[chan] = usrp_dev->get_tx_freq(chan);
 
 	return true;
 }
 
-bool uhd_device::setRxFreq(double wFreq)
+bool uhd_device::setRxFreq(double wFreq, size_t chan)
 {
-	uhd::tune_result_t tr = usrp_dev->set_rx_freq(wFreq);
+	if (chan >= rx_freqs.size()) {
+		LOG(ALERT) << "Requested non-existent channel " << chan;
+		return false;
+	}
+
+	uhd::tune_result_t tr = usrp_dev->set_rx_freq(wFreq, chan);
 	LOG(INFO) << "\n" << tr.to_pp_string();
-	rx_freq = usrp_dev->get_rx_freq();
+	rx_freqs[chan] = usrp_dev->get_rx_freq(chan);
 
 	return true;
 }
 
+double uhd_device::getTxFreq(size_t chan)
+{
+	if (chan >= tx_freqs.size()) {
+		LOG(ALERT) << "Requested non-existent channel " << chan;
+		return 0.0;
+	}
+
+	return tx_freqs[chan];
+}
+
+double uhd_device::getRxFreq(size_t chan)
+{
+	if (chan >= rx_freqs.size()) {
+		LOG(ALERT) << "Requested non-existent channel " << chan;
+		return 0.0;
+	}
+
+	return rx_freqs[chan];
+}
+
 bool uhd_device::recv_async_msg()
 {
 	uhd::async_metadata_t md;
@@ -1085,7 +1170,7 @@
 	}
 }
 
-RadioDevice *RadioDevice::make(int sps, bool skip_rx)
+RadioDevice *RadioDevice::make(size_t sps, size_t chans)
 {
-	return new uhd_device(sps, skip_rx);
+	return new uhd_device(sps, chans);
 }
diff --git a/Transceiver52M/USRPDevice.cpp b/Transceiver52M/USRPDevice.cpp
index 1fff124..e330bc3 100644
--- a/Transceiver52M/USRPDevice.cpp
+++ b/Transceiver52M/USRPDevice.cpp
@@ -59,7 +59,7 @@
 
 const double USRPDevice::masterClockRate = 52.0e6;
 
-USRPDevice::USRPDevice(int sps, bool skipRx)
+USRPDevice::USRPDevice(size_t sps, size_t)
   : skipRx(skipRx)
 {
   LOG(INFO) << "creating USRP device...";
@@ -266,49 +266,66 @@
   return m_dbRx->gain_min();
 }
 
-double USRPDevice::setTxGain(double dB) {
- 
-   writeLock.lock();
-   if (dB > maxTxGain()) dB = maxTxGain();
-   if (dB < minTxGain()) dB = minTxGain();
+double USRPDevice::setTxGain(double dB, size_t chan)
+{
+  if (chan) {
+    LOG(ALERT) << "Invalid channel " << chan;
+    return 0.0;
+  }
 
-   LOG(NOTICE) << "Setting TX gain to " << dB << " dB.";
+  writeLock.lock();
+  if (dB > maxTxGain())
+    dB = maxTxGain();
+  if (dB < minTxGain())
+    dB = minTxGain();
 
-   if (!m_dbTx->set_gain(dB))
-     LOG(ERR) << "Error setting TX gain";
+  LOG(NOTICE) << "Setting TX gain to " << dB << " dB.";
 
-   writeLock.unlock();
-  
-   return dB;
+  if (!m_dbTx->set_gain(dB))
+    LOG(ERR) << "Error setting TX gain";
+
+  writeLock.unlock();
+
+  return dB;
 }
 
 
-double USRPDevice::setRxGain(double dB) {
+double USRPDevice::setRxGain(double dB, size_t chan)
+{
+  if (chan) {
+    LOG(ALERT) << "Invalid channel " << chan;
+    return 0.0;
+  }
 
-   writeLock.lock();
-   if (dB > maxRxGain()) dB = maxRxGain();
-   if (dB < minRxGain()) dB = minRxGain();
-   
-   LOG(NOTICE) << "Setting RX gain to " << dB << " dB.";
+  dB = 47.0;
 
-   if (!m_dbRx->set_gain(dB))
-     LOG(ERR) << "Error setting RX gain";
-  
-   writeLock.unlock();
-   
-   return dB;
+  writeLock.lock();
+  if (dB > maxRxGain())
+    dB = maxRxGain();
+  if (dB < minRxGain())
+    dB = minRxGain();
+
+  LOG(NOTICE) << "Setting RX gain to " << dB << " dB.";
+
+  if (!m_dbRx->set_gain(dB))
+    LOG(ERR) << "Error setting RX gain";
+
+  writeLock.unlock();
+
+  return dB;
 }
 
 
 // NOTE: Assumes sequential reads
-int USRPDevice::readSamples(short *buf, int len, bool *overrun, 
-			    TIMESTAMP timestamp,
-			    bool *underrun,
-			    unsigned *RSSI) 
+int USRPDevice::readSamples(std::vector<short *> &bufs, int len, bool *overrun,
+                            TIMESTAMP timestamp, bool *underrun, unsigned *RSSI)
 {
 #ifndef SWLOOPBACK 
-  if (!m_uRx) return 0;
-  
+  if (!m_uRx)
+    return 0;
+
+  short *buf = bufs[0];
+
   timestamp += timestampOffset;
   
   if (timestamp + len < timeStart) {
@@ -450,17 +467,20 @@
 #endif
 }
 
-int USRPDevice::writeSamples(short *buf, int len, bool *underrun, 
-			     unsigned long long timestamp,
-			     bool isControl) 
+int USRPDevice::writeSamples(std::vector<short *> &bufs, int len,
+                             bool *underrun, unsigned long long timestamp,
+                             bool isControl)
 {
   writeLock.lock();
 
 #ifndef SWLOOPBACK 
-  if (!m_uTx) return 0;
- 
+  if (!m_uTx)
+    return 0;
+
+  short *buf = bufs[0];
+
   static uint32_t outData[128*20];
- 
+
   for (int i = 0; i < len*2; i++) {
 	buf[i] = host_to_usrp_short(buf[i]);
   }
@@ -512,7 +532,9 @@
   uint32_t *wordPtr = (uint32_t *) data;
   *wordPtr = host_to_usrp_u32(*wordPtr);
   bool tmpUnderrun;
-  if (writeSamples((short *) data,1,&tmpUnderrun,timestamp & 0x0ffffffffll,true)) {
+
+  std::vector<short *> buf(1, data);
+  if (writeSamples(buf, 1, &tmpUnderrun, timestamp & 0x0ffffffffll, true)) {
     pingTimestamp = timestamp;
     return true;
   }
@@ -523,10 +545,15 @@
 }
 
 #ifndef SWLOOPBACK 
-bool USRPDevice::setTxFreq(double wFreq)
+bool USRPDevice::setTxFreq(double wFreq, size_t chan)
 {
   usrp_tune_result result;
 
+  if (chan) {
+    LOG(ALERT) << "Invalid channel " << chan;
+    return false;
+  }
+
   if (m_uTx->tune(txSubdevSpec.side, m_dbTx, wFreq, &result)) {
     LOG(INFO) << "set TX: " << wFreq << std::endl
               << "    baseband freq: " << result.baseband_freq << std::endl
@@ -543,10 +570,15 @@
   }
 }
 
-bool USRPDevice::setRxFreq(double wFreq)
+bool USRPDevice::setRxFreq(double wFreq, size_t chan)
 {
   usrp_tune_result result;
 
+  if (chan) {
+    LOG(ALERT) << "Invalid channel " << chan;
+    return false;
+  }
+
   if (m_uRx->tune(0, m_dbRx, wFreq, &result)) {
     LOG(INFO) << "set RX: " << wFreq << std::endl
               << "    baseband freq: " << result.baseband_freq << std::endl
@@ -569,7 +601,7 @@
 bool USRPDevice::setRxFreq(double wFreq) { return true;};
 #endif
 
-RadioDevice *RadioDevice::make(int sps, bool skipRx)
+RadioDevice *RadioDevice::make(size_t sps, size_t chans)
 {
-	return new USRPDevice(sps, skipRx);
+	return new USRPDevice(sps, chans);
 }
diff --git a/Transceiver52M/USRPDevice.h b/Transceiver52M/USRPDevice.h
index dc86f0e..cfc6222 100644
--- a/Transceiver52M/USRPDevice.h
+++ b/Transceiver52M/USRPDevice.h
@@ -93,16 +93,10 @@
   bool   firstRead;
 #endif
 
-  /** Set the transmission frequency */
-  bool tx_setFreq(double freq, double *actual_freq);
-
-  /** Set the receiver frequency */
-  bool rx_setFreq(double freq, double *actual_freq);
-  
  public:
 
   /** Object constructor */
-  USRPDevice(int sps, bool skipRx);
+  USRPDevice(size_t sps, size_t chans = 1);
 
   /** Instantiate the USRP */
   int open(const std::string &, bool);
@@ -114,7 +108,7 @@
   bool stop();
 
   /** Set priority not supported */
-  void setPriority() { return; }
+  void setPriority() { }
 
   enum TxWindowType getWindowType() { return TX_WINDOW_USRP1; }
 
@@ -128,10 +122,9 @@
 	@param RSSI The received signal strength of the read result
 	@return The number of samples actually read
   */
-  int  readSamples(short *buf, int len, bool *overrun, 
-		   TIMESTAMP timestamp = 0xffffffff,
-		   bool *underrun = NULL,
-		   unsigned *RSSI = NULL);
+  int readSamples(std::vector<short *> &buf, int len, bool *overrun,
+                  TIMESTAMP timestamp = 0xffffffff, bool *underrun = NULL,
+                  unsigned *RSSI = NULL);
   /**
         Write samples to the USRP.
         @param buf Contains the data to be written.
@@ -141,18 +134,17 @@
         @param isControl Set if data is a control packet, e.g. a ping command
         @return The number of samples actually written
   */
-  int  writeSamples(short *buf, int len, bool *underrun, 
-		    TIMESTAMP timestamp = 0xffffffff,
-		    bool isControl = false);
- 
+  int writeSamples(std::vector<short *> &bufs, int len, bool *underrun,
+                   TIMESTAMP timestamp = 0xffffffff, bool isControl = false);
+
   /** Update the alignment between the read and write timestamps */
   bool updateAlignment(TIMESTAMP timestamp);
-  
+
   /** Set the transmitter frequency */
-  bool setTxFreq(double wFreq);
+  bool setTxFreq(double wFreq, size_t chan = 0);
 
   /** Set the receiver frequency */
-  bool setRxFreq(double wFreq);
+  bool setRxFreq(double wFreq, size_t chan = 0);
 
   /** Returns the starting write Timestamp*/
   TIMESTAMP initialWriteTimestamp(void) { return 20000;}
@@ -167,10 +159,10 @@
   double fullScaleOutputValue() {return 9450.0;}
 
   /** sets the receive chan gain, returns the gain setting **/
-  double setRxGain(double dB);
+  double setRxGain(double dB, size_t chan = 0);
 
   /** get the current receive gain */
-  double getRxGain(void) {return rxGain;}
+  double getRxGain(size_t chan = 0) { return rxGain; }
 
   /** return maximum Rx Gain **/
   double maxRxGain(void);
@@ -179,7 +171,7 @@
   double minRxGain(void);
 
   /** sets the transmit chan gain, returns the gain setting **/
-  double setTxGain(double dB);
+  double setTxGain(double dB, size_t chan = 0);
 
   /** return maximum Tx Gain **/
   double maxTxGain(void);
@@ -187,13 +179,12 @@
   /** return minimum Rx Gain **/
   double minTxGain(void);
 
-
   /** Return internal status values */
-  inline double getTxFreq() { return 0;}
-  inline double getRxFreq() { return 0;}
-  inline double getSampleRate() {return actualSampleRate;}
+  inline double getTxFreq(size_t chan = 0) { return 0; }
+  inline double getRxFreq(size_t chan = 0) { return 0; }
+  inline double getSampleRate() { return actualSampleRate; }
   inline double numberRead() { return samplesRead; }
-  inline double numberWritten() { return samplesWritten;}
+  inline double numberWritten() { return samplesWritten; }
 
 };
 
diff --git a/Transceiver52M/radioDevice.h b/Transceiver52M/radioDevice.h
index e08904b..e577bc5 100644
--- a/Transceiver52M/radioDevice.h
+++ b/Transceiver52M/radioDevice.h
@@ -16,6 +16,7 @@
 #define __RADIO_DEVICE_H__
 
 #include <string>
+#include <vector>
 
 #ifdef HAVE_CONFIG_H
 #include "config.h"
@@ -36,7 +37,7 @@
   /* Radio interface types */
   enum RadioInterfaceType { NORMAL, RESAMP_64M, RESAMP_100M };
 
-  static RadioDevice *make(int sps, bool skipRx = false);
+  static RadioDevice *make(size_t sps, size_t chans = 1);
 
   /** Initialize the USRP */
   virtual int open(const std::string &args = "", bool extref = false)=0;
@@ -63,10 +64,9 @@
 	@param RSSI The received signal strength of the read result
 	@return The number of samples actually read
   */
-  virtual int readSamples(short *buf, int len, bool *overrun, 
-		   TIMESTAMP timestamp = 0xffffffff,
-		   bool *underrun = 0,
-		   unsigned *RSSI = 0)=0;
+  virtual int readSamples(std::vector<short *> &bufs, int len, bool *overrun,
+                          TIMESTAMP timestamp = 0xffffffff, bool *underrun = 0,
+                          unsigned *RSSI = 0) = 0;
   /**
         Write samples to the radio.
         @param buf Contains the data to be written.
@@ -76,18 +76,17 @@
         @param isControl Set if data is a control packet, e.g. a ping command
         @return The number of samples actually written
   */
-  virtual int writeSamples(short *buf, int len, bool *underrun, 
-		    TIMESTAMP timestamp,
-		    bool isControl=false)=0;
- 
+  virtual int writeSamples(std::vector<short *> &bufs, int len, bool *underrun,
+                           TIMESTAMP timestamp, bool isControl = false) = 0;
+
   /** Update the alignment between the read and write timestamps */
   virtual bool updateAlignment(TIMESTAMP timestamp)=0;
-  
+
   /** Set the transmitter frequency */
-  virtual bool setTxFreq(double wFreq)=0;
+  virtual bool setTxFreq(double wFreq, size_t chan = 0) = 0;
 
   /** Set the receiver frequency */
-  virtual bool setRxFreq(double wFreq)=0;
+  virtual bool setRxFreq(double wFreq, size_t chan = 0) = 0;
 
   /** Returns the starting write Timestamp*/
   virtual TIMESTAMP initialWriteTimestamp(void)=0;
@@ -102,10 +101,10 @@
   virtual double fullScaleOutputValue()=0;
 
   /** sets the receive chan gain, returns the gain setting **/
-  virtual double setRxGain(double dB)=0;
+  virtual double setRxGain(double dB, size_t chan = 0) = 0;
 
   /** gets the current receive gain **/
-  virtual double getRxGain(void)=0;
+  virtual double getRxGain(size_t chan = 0) = 0;
 
   /** return maximum Rx Gain **/
   virtual double maxRxGain(void) = 0;
@@ -114,7 +113,7 @@
   virtual double minRxGain(void) = 0;
 
   /** sets the transmit chan gain, returns the gain setting **/
-  virtual double setTxGain(double dB)=0;
+  virtual double setTxGain(double dB, size_t chan = 0) = 0;
 
   /** return maximum Tx Gain **/
   virtual double maxTxGain(void) = 0;
@@ -123,8 +122,8 @@
   virtual double minTxGain(void) = 0;
 
   /** Return internal status values */
-  virtual double getTxFreq()=0;
-  virtual double getRxFreq()=0;
+  virtual double getTxFreq(size_t chan = 0) = 0;
+  virtual double getRxFreq(size_t chan = 0) = 0;
   virtual double getSampleRate()=0;
   virtual double numberRead()=0;
   virtual double numberWritten()=0;
diff --git a/Transceiver52M/radioInterface.cpp b/Transceiver52M/radioInterface.cpp
index a8a54a5..f98194f 100644
--- a/Transceiver52M/radioInterface.cpp
+++ b/Transceiver52M/radioInterface.cpp
@@ -35,13 +35,12 @@
 
 RadioInterface::RadioInterface(RadioDevice *wRadio,
 			       int wReceiveOffset,
-			       int wSPS,
+			       size_t sps, size_t chans,
 			       GSM::Time wStartTime)
-  : underrun(false), sendCursor(0), recvCursor(0), mOn(false),
-    mRadio(wRadio), receiveOffset(wReceiveOffset),
-    mSPSTx(wSPS), mSPSRx(1), powerScaling(1.0),
-    loadTest(false), sendBuffer(NULL), recvBuffer(NULL),
-    convertRecvBuffer(NULL), convertSendBuffer(NULL)
+  : mRadio(wRadio), mSPSTx(sps), mSPSRx(1), mChans(chans),
+    sendCursor(0), recvCursor(0), underrun(false), overrun(false),
+    receiveOffset(wReceiveOffset), mOn(false), powerScaling(1.0),
+    loadTest(false)
 {
   mClock.set(wStartTime);
 }
@@ -56,13 +55,26 @@
   if (type != RadioDevice::NORMAL)
     return false;
 
+  if (!mChans) {
+    LOG(ALERT) << "Invalid number of channels " << mChans;
+    return false;
+  }
+
   close();
 
-  sendBuffer = new signalVector(CHUNK * mSPSTx);
-  recvBuffer = new signalVector(NUMCHUNKS * CHUNK * mSPSRx);
+  sendBuffer.resize(mChans);
+  recvBuffer.resize(mChans);
+  convertSendBuffer.resize(mChans);
+  convertRecvBuffer.resize(mChans);
+  mReceiveFIFO.resize(mChans);
 
-  convertSendBuffer = new short[sendBuffer->size() * 2];
-  convertRecvBuffer = new short[recvBuffer->size() * 2];
+  for (size_t i = 0; i < mChans; i++) {
+    sendBuffer[i] = new signalVector(CHUNK * mSPSTx);
+    recvBuffer[i] = new signalVector(NUMCHUNKS * CHUNK * mSPSRx);
+
+    convertSendBuffer[i] = new short[sendBuffer[i]->size() * 2];
+    convertRecvBuffer[i] = new short[recvBuffer[i]->size() * 2];
+  }
 
   sendCursor = 0;
   recvCursor = 0;
@@ -72,18 +84,24 @@
 
 void RadioInterface::close()
 {
-  delete sendBuffer;
-  delete recvBuffer;
-  delete convertSendBuffer;
-  delete convertRecvBuffer;
+  for (size_t i = 0; i < sendBuffer.size(); i++)
+    delete sendBuffer[i];
 
-  sendBuffer = NULL;
-  recvBuffer = NULL;
-  convertRecvBuffer = NULL;
-  convertSendBuffer = NULL;
+  for (size_t i = 0; i < recvBuffer.size(); i++)
+    delete recvBuffer[i];
+
+  for (size_t i = 0; i < convertSendBuffer.size(); i++)
+    delete convertSendBuffer[i];
+
+  for (size_t i = 0; i < convertRecvBuffer.size(); i++)
+    delete convertRecvBuffer[i];
+
+  sendBuffer.resize(0);
+  recvBuffer.resize(0);
+  convertSendBuffer.resize(0);
+  convertRecvBuffer.resize(0);
 }
 
-
 double RadioInterface::fullScaleInputValue(void) {
   return mRadio->fullScaleInputValue();
 }
@@ -93,11 +111,16 @@
 }
 
 
-void RadioInterface::setPowerAttenuation(double atten)
+void RadioInterface::setPowerAttenuation(double atten, size_t chan)
 {
   double rfGain, digAtten;
 
-  rfGain = mRadio->setTxGain(mRadio->maxTxGain() - atten);
+  if (chan >= mChans) {
+    LOG(ALERT) << "Invalid channel requested";
+    return;
+  }
+
+  rfGain = mRadio->setTxGain(mRadio->maxTxGain() - atten, chan);
   digAtten = atten - mRadio->maxTxGain() + rfGain;
 
   if (digAtten < 1.0)
@@ -138,14 +161,14 @@
   return newVector.size();
 }
 
-bool RadioInterface::tuneTx(double freq)
+bool RadioInterface::tuneTx(double freq, size_t chan)
 {
-  return mRadio->setTxFreq(freq);
+  return mRadio->setTxFreq(freq, chan);
 }
 
-bool RadioInterface::tuneRx(double freq)
+bool RadioInterface::tuneRx(double freq, size_t chan)
 {
-  return mRadio->setRxFreq(freq);
+  return mRadio->setRxFreq(freq, chan);
 }
 
 
@@ -183,24 +206,28 @@
 }
 #endif
 
-void RadioInterface::driveTransmitRadio(signalVector &radioBurst, bool zeroBurst)
+void RadioInterface::driveTransmitRadio(std::vector<signalVector *> &bursts,
+                                        std::vector<bool> &zeros)
 {
   if (!mOn)
     return;
 
-  radioifyVector(radioBurst,
-                 (float *) (sendBuffer->begin() + sendCursor), zeroBurst);
+  for (size_t i = 0; i < mChans; i++) {
+    radioifyVector(*bursts[i],
+                   (float *) (sendBuffer[i]->begin() + sendCursor), zeros[i]);
+  }
 
-  sendCursor += radioBurst.size();
+  sendCursor += bursts[0]->size();
 
   pushBuffer();
 }
 
-void RadioInterface::driveReceiveRadio() {
+bool RadioInterface::driveReceiveRadio()
+{
+  radioVector *burst = NULL;
 
-  if (!mOn) return;
-
-  if (mReceiveFIFO.size() > 8) return;
+  if (!mOn)
+    return false;
 
   pullBuffer();
 
@@ -215,23 +242,23 @@
   //    GSM bursts and pass up to Transceiver
   // Using the 157-156-156-156 symbols per timeslot format.
   while (rcvSz > (symbolsPerSlot + (tN % 4 == 0)) * mSPSRx) {
-    signalVector rxVector((symbolsPerSlot + (tN % 4 == 0)) * mSPSRx);
-    unRadioifyVector((float *) (recvBuffer->begin() + readSz), rxVector);
     GSM::Time tmpTime = rcvClock;
-    if (rcvClock.FN() >= 0) {
-      //LOG(DEBUG) << "FN: " << rcvClock.FN();
-      radioVector *rxBurst = NULL;
-      if (!loadTest)
-        rxBurst = new radioVector(rxVector,tmpTime);
+
+    for (size_t i = 0; i < mChans; i++) {
+      signalVector rxVector((symbolsPerSlot + (tN % 4 == 0)) * mSPSRx);
+      unRadioifyVector((float *) (recvBuffer[i]->begin() + readSz), rxVector);
+
+      if (rcvClock.FN() >= 0)
+        burst = new radioVector(rxVector, tmpTime);
+
+      if (burst && (mReceiveFIFO[i].size() < 32))
+        mReceiveFIFO[i].write(burst);
       else {
-	if (tN % 4 == 0)
-	  rxBurst = new radioVector(*finalVec9,tmpTime);
-        else
-          rxBurst = new radioVector(*finalVec,tmpTime); 
+        delete burst;
       }
-      mReceiveFIFO.put(rxBurst); 
     }
-    mClock.incTN(); 
+
+    mClock.incTN();
     rcvClock.incTN();
     readSz += (symbolsPerSlot+(tN % 4 == 0)) * mSPSRx;
     rcvSz -= (symbolsPerSlot+(tN % 4 == 0)) * mSPSRx;
@@ -240,12 +267,16 @@
   }
 
   if (readSz > 0) {
-    memmove(recvBuffer->begin(),
-            recvBuffer->begin() + readSz,
-            (recvCursor - readSz) * 2 * sizeof(float));
+    for (size_t i = 0; i < recvBuffer.size(); i++) {
+      memmove(recvBuffer[i]->begin(),
+              recvBuffer[i]->begin() + readSz,
+              (recvCursor - readSz) * 2 * sizeof(float));
+    }
 
     recvCursor -= readSz;
   }
+
+  return true;
 }
 
 bool RadioInterface::isUnderrun()
@@ -256,18 +287,26 @@
   return retVal;
 }
 
-double RadioInterface::setRxGain(double dB)
+VectorFIFO* RadioInterface::receiveFIFO(size_t chan)
+{
+  if (chan >= mReceiveFIFO.size())
+    return NULL;
+
+  return &mReceiveFIFO[chan];
+}
+
+double RadioInterface::setRxGain(double dB, size_t chan)
 {
   if (mRadio)
-    return mRadio->setRxGain(dB);
+    return mRadio->setRxGain(dB, chan);
   else
     return -1;
 }
 
-double RadioInterface::getRxGain()
+double RadioInterface::getRxGain(size_t chan)
 {
   if (mRadio)
-    return mRadio->getRxGain();
+    return mRadio->getRxGain(chan);
   else
     return -1;
 }
@@ -279,7 +318,7 @@
   int num_recv;
   float *output;
 
-  if (recvCursor > recvBuffer->size() - CHUNK)
+  if (recvCursor > recvBuffer[0]->size() - CHUNK)
     return;
 
   /* Outer buffer access size is fixed */
@@ -293,9 +332,10 @@
           return;
   }
 
-  output = (float *) (recvBuffer->begin() + recvCursor);
-
-  convert_short_float(output, convertRecvBuffer, 2 * num_recv);
+  for (size_t i = 0; i < mChans; i++) {
+    output = (float *) (recvBuffer[i]->begin() + recvCursor);
+    convert_short_float(output, convertRecvBuffer[i], 2 * num_recv);
+  }
 
   underrun |= local_underrun;
 
@@ -311,12 +351,14 @@
   if (sendCursor < CHUNK)
     return;
 
-  if (sendCursor > sendBuffer->size())
+  if (sendCursor > sendBuffer[0]->size())
     LOG(ALERT) << "Send buffer overflow";
 
-  convert_float_short(convertSendBuffer,
-                      (float *) sendBuffer->begin(),
-                      powerScaling, 2 * sendCursor);
+  for (size_t i = 0; i < mChans; i++) {
+    convert_float_short(convertSendBuffer[i],
+                        (float *) sendBuffer[i]->begin(),
+                        powerScaling, 2 * sendCursor);
+  }
 
   /* Send the all samples in the send buffer */ 
   num_sent = mRadio->writeSamples(convertSendBuffer,
diff --git a/Transceiver52M/radioInterface.h b/Transceiver52M/radioInterface.h
index 84de1e5..1e58ecb 100644
--- a/Transceiver52M/radioInterface.h
+++ b/Transceiver52M/radioInterface.h
@@ -30,19 +30,20 @@
 
   Thread mAlignRadioServiceLoopThread;	      ///< thread that synchronizes transmit and receive sections
 
-  VectorFIFO  mReceiveFIFO;		      ///< FIFO that holds receive  bursts
+  std::vector<VectorFIFO>  mReceiveFIFO;      ///< FIFO that holds receive  bursts
 
   RadioDevice *mRadio;			      ///< the USRP object
 
-  int mSPSTx;
-  int mSPSRx;
-  signalVector *sendBuffer;
-  signalVector *recvBuffer;
+  size_t mSPSTx;
+  size_t mSPSRx;
+  size_t mChans;
+  std::vector<signalVector *> sendBuffer;
+  std::vector<signalVector *> recvBuffer;
   unsigned sendCursor;
   unsigned recvCursor;
 
-  short *convertRecvBuffer;
-  short *convertSendBuffer;
+  std::vector<short *> convertRecvBuffer;
+  std::vector<short *> convertSendBuffer;
 
   bool underrun;			      ///< indicates writes to USRP are too slow
   bool overrun;				      ///< indicates reads from USRP are too slow
@@ -89,43 +90,41 @@
   /** constructor */
   RadioInterface(RadioDevice* wRadio = NULL,
 		 int receiveOffset = 3,
-		 int wSPS = 4,
+		 size_t sps = 4, size_t chans = 1,
 		 GSM::Time wStartTime = GSM::Time(0));
-    
+
   /** destructor */
   virtual ~RadioInterface();
 
   /** check for underrun, resets underrun value */
   bool isUnderrun();
-  
-  /** attach an existing USRP to this interface */
-  void attach(RadioDevice *wRadio, int wRadioOversampling);
 
   /** return the receive FIFO */
-  VectorFIFO* receiveFIFO() { return &mReceiveFIFO;}
+  VectorFIFO* receiveFIFO(size_t chan = 0);
 
   /** return the basestation clock */
   RadioClock* getClock(void) { return &mClock;};
 
   /** set transmit frequency */
-  bool tuneTx(double freq);
+  bool tuneTx(double freq, size_t chan = 0);
 
   /** set receive frequency */
-  bool tuneRx(double freq);
+  bool tuneRx(double freq, size_t chan = 0);
 
   /** set receive gain */
-  double setRxGain(double dB);
+  double setRxGain(double dB, size_t chan = 0);
 
   /** get receive gain */
-  double getRxGain(void);
+  double getRxGain(size_t chan = 0);
 
   /** drive transmission of GSM bursts */
-  void driveTransmitRadio(signalVector &radioBurst, bool zeroBurst);
+  void driveTransmitRadio(std::vector<signalVector *> &bursts,
+                          std::vector<bool> &zeros);
 
   /** drive reception of GSM bursts */
-  void driveReceiveRadio();
+  bool driveReceiveRadio();
 
-  void setPowerAttenuation(double atten);
+  void setPowerAttenuation(double atten, size_t chan = 0);
 
   /** returns the full-scale transmit amplitude **/
   double fullScaleInputValue();
@@ -169,7 +168,7 @@
 
   RadioInterfaceResamp(RadioDevice* wRadio = NULL,
 		       int receiveOffset = 3,
-		       int wSPS = 4,
+		       size_t wSPS = 4, size_t chans = 1,
 		       GSM::Time wStartTime = GSM::Time(0));
 
   ~RadioInterfaceResamp();
diff --git a/Transceiver52M/radioInterfaceResamp.cpp b/Transceiver52M/radioInterfaceResamp.cpp
index 6c3839a..95ed16d 100644
--- a/Transceiver52M/radioInterfaceResamp.cpp
+++ b/Transceiver52M/radioInterfaceResamp.cpp
@@ -55,14 +55,11 @@
 static int resamp_outrate = 0;
 static int resamp_outchunk = 0;
 
-short *convertRecvBuffer = NULL;
-short *convertSendBuffer = NULL;
-
 RadioInterfaceResamp::RadioInterfaceResamp(RadioDevice *wRadio,
 					   int wReceiveOffset,
-					   int wSPS,
+					   size_t sps, size_t chan,
 					   GSM::Time wStartTime)
-	: RadioInterface(wRadio, wReceiveOffset, wSPS, wStartTime),
+	: RadioInterface(wRadio, wReceiveOffset, sps, chan, wStartTime),
 	  innerSendBuffer(NULL), outerSendBuffer(NULL),
 	  innerRecvBuffer(NULL), outerRecvBuffer(NULL)
 {
@@ -87,12 +84,15 @@
 	outerSendBuffer = NULL;
 	innerRecvBuffer = NULL;
 	outerRecvBuffer = NULL;
-	sendBuffer = NULL;
-	recvBuffer = NULL;
 
 	upsampler = NULL;
 	dnsampler = NULL;
 
+	if (sendBuffer.size())
+		sendBuffer[0] = NULL;
+	if (recvBuffer.size())
+		recvBuffer[0] = NULL;
+
 	RadioInterface::close();
 }
 
@@ -101,8 +101,19 @@
 {
 	float cutoff = 1.0f;
 
+	if (mChans != 1) {
+		LOG(ALERT) << "Unsupported channel configuration " << mChans;
+		return false;
+	}
+
 	close();
 
+	sendBuffer.resize(1);
+	recvBuffer.resize(1);
+	convertSendBuffer.resize(1);
+	convertRecvBuffer.resize(1);
+	mReceiveFIFO.resize(1);
+
 	switch (type) {
 	case RadioDevice::RESAMP_64M:
 		resamp_inrate = RESAMP_64M_INRATE;
@@ -156,11 +167,11 @@
 	innerRecvBuffer =
 		new signalVector(NUMCHUNKS * resamp_inchunk / mSPSTx);
 
-	convertSendBuffer = new short[outerSendBuffer->size() * 2];
-	convertRecvBuffer = new short[outerRecvBuffer->size() * 2];
+	convertSendBuffer[0] = new short[outerSendBuffer->size() * 2];
+	convertRecvBuffer[0] = new short[outerRecvBuffer->size() * 2];
 
-	sendBuffer = innerSendBuffer;
-	recvBuffer = innerRecvBuffer;
+	sendBuffer[0] = innerSendBuffer;
+	recvBuffer[0] = innerRecvBuffer;
 
 	return true;
 }
@@ -186,7 +197,7 @@
 	}
 
 	convert_short_float((float *) outerRecvBuffer->begin(),
-			    convertRecvBuffer, 2 * resamp_outchunk);
+			    convertRecvBuffer[0], 2 * resamp_outchunk);
 
 	underrun |= local_underrun;
 	readTimestamp += (TIMESTAMP) resamp_outchunk;
@@ -227,7 +238,7 @@
 		LOG(ALERT) << "Sample rate downsampling error";
 	}
 
-	convert_float_short(convertSendBuffer,
+	convert_float_short(convertSendBuffer[0],
 			    (float *) outerSendBuffer->begin(),
 			    powerScaling, 2 * outer_len);
 
diff --git a/Transceiver52M/radioVector.cpp b/Transceiver52M/radioVector.cpp
index 043effa..8869821 100644
--- a/Transceiver52M/radioVector.cpp
+++ b/Transceiver52M/radioVector.cpp
@@ -70,21 +70,6 @@
 	return true;
 }
 
-unsigned VectorFIFO::size()
-{
-	return mQ.size();
-}
-
-void VectorFIFO::put(radioVector *ptr)
-{
-	mQ.put((void*) ptr);
-}
-
-radioVector *VectorFIFO::get()
-{
-	return (radioVector*) mQ.get();
-}
-
 GSM::Time VectorQueue::nextTime() const
 {
 	GSM::Time retVal;
diff --git a/Transceiver52M/radioVector.h b/Transceiver52M/radioVector.h
index 8dc1c13..0b38bff 100644
--- a/Transceiver52M/radioVector.h
+++ b/Transceiver52M/radioVector.h
@@ -47,15 +47,7 @@
 	std::vector<float>::iterator it;
 };
 
-class VectorFIFO {
-public:
-	unsigned size();
-	void put(radioVector *ptr);
-	radioVector *get();
-
-private:
-	PointerFIFO mQ;
-};
+class VectorFIFO : public InterthreadQueue<radioVector> { };
 
 class VectorQueue : public InterthreadPriorityQueue<radioVector> {
 public:
diff --git a/Transceiver52M/runTransceiver.cpp b/Transceiver52M/runTransceiver.cpp
index 6a7cc53..395908c 100644
--- a/Transceiver52M/runTransceiver.cpp
+++ b/Transceiver52M/runTransceiver.cpp
@@ -27,7 +27,6 @@
 
 #include "Transceiver.h"
 #include "radioDevice.h"
-#include "DummyLoad.h"
 
 #include <time.h>
 #include <signal.h>
@@ -108,16 +107,21 @@
 
 int main(int argc, char *argv[])
 {
-  int trxPort, radioType, extref = 0, fail = 0;
-  std::string deviceArgs, logLevel, trxAddr;
+  int trxPort, radioType, chans = 1, extref = 0, fail = 0;
+  std::string logLevel, trxAddr, deviceArgs = "";
   RadioDevice *usrp = NULL;
   RadioInterface *radio = NULL;
   Transceiver *trx = NULL;
+  VectorFIFO *fifo = NULL;
 
-  if (argc == 3)
+  if (argc == 3) {
     deviceArgs = std::string(argv[2]);
-  else
-    deviceArgs = "";
+    chans = atoi(argv[1]);
+  } else if (argc == 2) {
+    chans = atoi(argv[1]);
+  } else if (argc != 1) {
+    std::cout << argv[0] << " <number of channels> <device args>" << std::endl;
+  }
 
   if (signal(SIGINT, ctrlCHandler) == SIG_ERR) {
     std::cerr << "Couldn't install signal handler for SIGINT" << std::endl;
@@ -151,7 +155,7 @@
 
   srandom(time(NULL));
 
-  usrp = RadioDevice::make(SPS);
+  usrp = RadioDevice::make(SPS, chans);
   radioType = usrp->open(deviceArgs, extref);
   if (radioType < 0) {
     LOG(ALERT) << "Transceiver exiting..." << std::endl;
@@ -160,11 +164,11 @@
 
   switch (radioType) {
   case RadioDevice::NORMAL:
-    radio = new RadioInterface(usrp, 3, SPS, false);
+    radio = new RadioInterface(usrp, 3, SPS, chans);
     break;
   case RadioDevice::RESAMP_64M:
   case RadioDevice::RESAMP_100M:
-    radio = new RadioInterfaceResamp(usrp, 3, SPS, false);
+    radio = new RadioInterfaceResamp(usrp, 3, SPS, chans);
     break;
   default:
     LOG(ALERT) << "Unsupported configuration";
@@ -177,13 +181,24 @@
     goto shutdown;
   }
 
-  trx = new Transceiver(trxPort, trxAddr.c_str(), SPS, GSM::Time(3,0), radio);
+  trx = new Transceiver(trxPort, trxAddr.c_str(),
+                        SPS, chans, GSM::Time(3,0), radio);
   if (!trx->init()) {
     LOG(ALERT) << "Failed to initialize transceiver";
     fail = 1;
     goto shutdown;
   }
-  trx->receiveFIFO(radio->receiveFIFO());
+
+  for (int i = 0; i < chans; i++) {
+    fifo = radio->receiveFIFO(i);
+    if (fifo && trx->receiveFIFO(fifo, i))
+      continue;
+
+    LOG(ALERT) << "Could not attach FIFO to channel " << i;
+    fail = 1;
+    goto shutdown;
+  }
+
   trx->start();
 
   while (!gbShutdown)