add DMA based receiver support

Author: sandeepmistry

libraries/I2S/examples/InputSerialPlotter/InputSerialPlotter.ino

@@ -0,0 +1,26 @@
+#include <I2S.h>
+
+void setup() {
+  // Open serial communications and wait for port to open:
+  Serial.begin(115200);
+  while (!Serial) {
+    ; // wait for serial port to connect. Needed for native USB port only
+  }
+
+  // start I2S at 8 kHz with 32-bits per sample
+  if (I2S.begin(I2S_PHILIPS_MODE, 8000, 32)) {
+    Serial.println("Failed to initialize I2S!");
+    while (1); // do nothing
+  }
+}
+
+void loop() {
+  // read a sample
+  int sample = I2S.read();
+
+  if (sample) {
+    // if it's non-zero print value to serial
+    Serial.println(sample);
+  }
+}
+

libraries/I2S/src/I2S.cpp

@@ -40,7 +40,8 @@ I2SClass::I2SClass(uint8_t deviceIndex, uint8_t clockGenerator, uint8_t sdPin, u
   _bitsPerSample(0),
   _dmaTransferInProgress(false),
 
-  _onTransmit(NULL)
+  _onTransmit(NULL),
+  _onReceive(NULL)
 {
 }
 
@@ -143,20 +144,35 @@ int I2SClass::available()
     enableReceiver();
   }
 
-  return (_bitsPerSample / 8);
-}
+  uint8_t enableInterrupts = ((__get_PRIMASK() & 0x1) == 0);
+  size_t avail;
 
-int I2SClass::read()
-{
-  if (_state != I2S_STATE_RECEIVER) {
-    enableReceiver();
+  // disable interrupts,
+  __disable_irq();
+
+  avail = _doubleBuffer.available();
+
+  if (_dmaTransferInProgress == false && _doubleBuffer.available() == 0) {
+    _dmaTransferInProgress = true;
+
+    DMA.transfer(_dmaChannel, i2sd.data(_deviceIndex), _doubleBuffer.data(), _doubleBuffer.availableForWrite());
+
+    _doubleBuffer.swap();
   }
 
-  while(!i2sd.rxReady(_deviceIndex));
+  if (enableInterrupts) {
+    // re-enable the interrupts
+    __enable_irq();
+  }
 
-  int sample = i2sd.readData(_deviceIndex);
+  return avail;
+}
+
+int I2SClass::read()
+{
+  int sample = 0;
 
-  i2sd.clearRxReady(_deviceIndex);
+  read(&sample, _bitsPerSample / 8);
 
   return sample;
 }
@@ -202,6 +218,35 @@ size_t I2SClass::availableForWrite()
   return space;
 }
 
+int I2SClass::read(void* buffer, size_t size)
+{
+  if (_state != I2S_STATE_RECEIVER) {
+    enableReceiver();
+  }
+
+  uint8_t enableInterrupts = ((__get_PRIMASK() & 0x1) == 0);
+
+  // disable interrupts,
+  __disable_irq();
+
+  int read = _doubleBuffer.read(buffer, size);
+
+  if (_dmaTransferInProgress == false && _doubleBuffer.available() == 0) {
+    _dmaTransferInProgress = true;
+
+    DMA.transfer(_dmaChannel, i2sd.data(_deviceIndex), _doubleBuffer.data(), _doubleBuffer.availableForWrite());
+
+    _doubleBuffer.swap();
+  }
+
+  if (enableInterrupts) {
+    // re-enable the interrupts
+    __enable_irq();
+  }
+
+  return read;
+}
+
 size_t I2SClass::write(int sample)
 {
   return write((int32_t)sample);
@@ -236,7 +281,7 @@ size_t I2SClass::write(const void *buffer, size_t size)
 
   written = _doubleBuffer.write(buffer, size);
 
-  if (_dmaTransferInProgress == false) {
+  if (_dmaTransferInProgress == false && _doubleBuffer.available()) {
     _dmaTransferInProgress = true;
 
     DMA.transfer(_dmaChannel, _doubleBuffer.data(), i2sd.data(_deviceIndex), _doubleBuffer.available());
@@ -257,6 +302,11 @@ void I2SClass::onTransmit(void(*function)(void))
   _onTransmit = function;
 }
 
+void I2SClass::onReceive(void(*function)(void))
+{
+  _onReceive = function;
+}
+
 void I2SClass::enableClock(int divider)
 {
   while (GCLK->STATUS.bit.SYNCBUSY);
@@ -313,7 +363,7 @@ void I2SClass::enableReceiver()
   i2sd.enableClockUnit(_deviceIndex);
   i2sd.enableSerializer(_deviceIndex);
 
-  DMA.incSrc(_dmaChannel);
+  DMA.incDst(_dmaChannel);
   DMA.onTransferComplete(_dmaChannel, I2SClass::onDmaTransferComplete);
   DMA.setTriggerSource(_dmaChannel, i2sd.dmaTriggerSource(_deviceIndex));
   DMA.setTransferWidth(_dmaChannel, _bitsPerSample);
@@ -323,16 +373,30 @@ void I2SClass::enableReceiver()
 
 void I2SClass::onTransferComplete(void)
 {
-  if (_doubleBuffer.available()) {
-    DMA.transfer(_dmaChannel, _doubleBuffer.data(), i2sd.data(_deviceIndex), _doubleBuffer.available());
-
-    _doubleBuffer.swap();
+  if (_state == I2S_STATE_TRANSMITTER) {
+    if (_doubleBuffer.available()) {
+      DMA.transfer(_dmaChannel, _doubleBuffer.data(), i2sd.data(_deviceIndex), _doubleBuffer.available());
+
+      _doubleBuffer.swap();
+    } else {
+      _dmaTransferInProgress = false;
+    }
+
+    if (_onTransmit) {
+      _onTransmit();
+    }
   } else {
-    _dmaTransferInProgress = false;
-  }
+    if (_doubleBuffer.available() == 0) {
+      DMA.transfer(_dmaChannel, i2sd.data(_deviceIndex), _doubleBuffer.data(), _doubleBuffer.availableForWrite());
+
+      _doubleBuffer.swap(_doubleBuffer.availableForWrite());
+    } else {
+      _dmaTransferInProgress = false;
+    }
 
-  if (_onTransmit) {
-    _onTransmit();
+    if (_onReceive) {
+      _onReceive();
+    }
   }
 }
 

libraries/I2S/src/I2S.h

@@ -47,11 +47,14 @@ class I2SClass : public Stream
 
   virtual size_t availableForWrite();
 
+  int read(void* buffer, size_t size);
+
   size_t write(int);
   size_t write(int32_t);
   size_t write(const void *buffer, size_t size);
 
   void onTransmit(void(*)(void));
+  void onReceive(void(*)(void));
 
 private:
   void enableClock(int divider);
@@ -87,6 +90,7 @@ class I2SClass : public Stream
   I2SDoubleBuffer _doubleBuffer;
 
   void (*_onTransmit)(void);
+  void (*_onReceive)(void);
 };
 
 #undef I2S

libraries/I2S/src/utility/I2SDoubleBuffer.cpp

@@ -34,11 +34,13 @@ void I2SDoubleBuffer::reset()
   _index = 0;
   _length[0] = 0;
   _length[1] = 0;
+  _readOffset[0] = 0;
+  _readOffset[1] = 0;
 }
 
 size_t I2SDoubleBuffer::availableForWrite()
 {
-  return (I2S_BUFFER_SIZE - _length[_index]);
+  return (I2S_BUFFER_SIZE - (_length[_index] - _readOffset[_index]));
 }
 
 size_t I2SDoubleBuffer::write(const void *buffer, size_t size)
@@ -60,23 +62,42 @@ size_t I2SDoubleBuffer::write(const void *buffer, size_t size)
   return size;
 }
 
+size_t I2SDoubleBuffer::read(void *buffer, size_t size)
+{
+  size_t avail = available();
+
+  if (size > avail) {
+    size = avail;
+  }
+
+  if (size == 0) {
+    return 0;
+  }
+
+  memcpy(buffer, &_buffer[_index][_readOffset[_index]], size);
+  _readOffset[_index] += size;
+
+  return size;
+}
+
 void* I2SDoubleBuffer::data()
 {
   return (void*)_buffer[_index];
 }
 
 size_t I2SDoubleBuffer::available()
 {
-  return _length[_index];
+  return _length[_index] - _readOffset[_index];
 }
 
-void I2SDoubleBuffer::swap()
+void I2SDoubleBuffer::swap(int length)
 {
   if (_index == 0) {
     _index = 1;
   } else {
     _index = 0;
   }
 
-  _length[_index] = 0;
+  _length[_index] = length;
+  _readOffset[_index] = 0;
 }

libraries/I2S/src/utility/I2SDoubleBuffer.h

@@ -34,13 +34,15 @@ class I2SDoubleBuffer
 
   size_t availableForWrite();
   size_t write(const void *buffer, size_t size);
+  size_t read(void *buffer, size_t size);
   void* data();
   size_t available();
-  void swap();
+  void swap(int length = 0);
 
 private:
   uint8_t _buffer[2][I2S_BUFFER_SIZE];
   volatile int _length[2];
+  volatile int _readOffset[2];
   volatile int _index; 
 };