first commit

examples/nrf51/nrf51_audio_tx/nrf51_audio_tx.ino

@@ -0,0 +1,143 @@
+// nrf51_audio_tx.pde
+// Sample sketch for nRF51822 and RadioHead
+//
+// Reads audio samples from an electret microphone
+// via the built in ADC in the nRF51822
+// Blocks of samples are sent by RadioHEad RH_NRF51 driver
+// to a matching receiver (see nrf51_audio_rx.pde)
+// Works with RedBear nRF51822 board.
+// See examples/nrf51_audiotx/nrf51_audio.pdf for connection details
+
+#include <nrf51.h>
+#include <nrf51_bitfields.h>
+#include <esb/nrf_esb.h>
+#include <RH_NRF51.h>
+
+// Number of audio samples per second
+// Should match SAMPLE_RATE in nrf51_audio_rx
+// Limited by the rate we can output samples in the receiver
+#define SAMPLE_RATE 5000
+
+// Number of 8 bit samples per packet
+#define PACKET_SIZE 200
+
+// Number of ADC data buffers
+#define NUM_BUFFERS 2
+
+// Minimum diff between smallest and largest reading in a given buffer
+// before we will send that buffer. We dont transmit quiet signals or silence
+#define USE_SQUELCH 0
+#define SQUELCH_THRESHOLD 2
+
+// These provide data transfer between the low level ADC interrupt handler and the 
+// higher level packet assembly and transmission
+volatile uint8_t  buffers[NUM_BUFFERS][PACKET_SIZE];
+volatile uint16_t sample_index = 0;          // Of the next sample to write
+volatile uint8_t  buffer_index = 0;          // Of the bufferbeing filled
+volatile bool     buffer_ready[NUM_BUFFERS]; // Set when a buffer is full
+
+// These hold the state of the high level transmitter code
+uint8_t  next_tx_buffer = 0;
+ 
+// Singleton instance of the radio driver
+RH_NRF51 driver;
+
+void setup() 
+{
+  delay(1000);
+  Serial.begin(9600);
+  while (!Serial) 
+    ; // wait for serial port to connect. 
+
+  if (!driver.init())
+    Serial.println("init failed");
+  // Defaults after init are 2.402 GHz (channel 2), 2Mbps, 0dBm
+
+  // Set up ADC
+  // Uses the builtin 1.2V bandgap reference and no prescaling
+  // AnalogInput2 is A0 on RedBear nrf51822 board
+  // Input voltage range is 0.0 to 1.2 V
+  NRF_ADC->CONFIG = ADC_CONFIG_RES_8bit << ADC_CONFIG_RES_Pos 
+                    | ADC_CONFIG_INPSEL_AnalogInputNoPrescaling << ADC_CONFIG_INPSEL_Pos 
+                    | ADC_CONFIG_REFSEL_VBG << ADC_CONFIG_REFSEL_Pos 
+                    | ADC_CONFIG_PSEL_AnalogInput2 << ADC_CONFIG_PSEL_Pos;
+  NRF_ADC->ENABLE = 1;
+  NRF_ADC->INTENSET = ADC_INTENSET_END_Msk; // Interrupt at completion of each sample
+    
+  // Set up TIMER to trigger ADC samples
+  // Use TIMER0
+  // Timer freq before prescaling is 16MHz (VARIANT_MCK)
+  // We set up a 32 bit timer that restarts every 100us and trggers a new ADC sample
+  NRF_TIMER0->PRESCALER = 0 << TIMER_PRESCALER_PRESCALER_Pos; 
+  NRF_TIMER0->MODE = TIMER_MODE_MODE_Timer << TIMER_BITMODE_BITMODE_Pos;
+  NRF_TIMER0->BITMODE = TIMER_BITMODE_BITMODE_32Bit << TIMER_BITMODE_BITMODE_Pos;
+  NRF_TIMER0->CC[0] = VARIANT_MCK / SAMPLE_RATE; // Counts per cycle
+  // When timer count expires, its cleared and restarts
+  NRF_TIMER0->SHORTS = TIMER_SHORTS_COMPARE0_CLEAR_Msk;
+  NRF_TIMER0->TASKS_START = 1;
+
+  // When the timer expires, trigger an ADC conversion
+  NRF_PPI->CH[0].EEP = (uint32_t)(&NRF_TIMER0->EVENTS_COMPARE[0]);
+  NRF_PPI->CH[0].TEP = (uint32_t)(&NRF_ADC->TASKS_START);
+  NRF_PPI->CHENSET = PPI_CHEN_CH0_Msk;
+
+  // Enable the ADC interrupt, and set the priority
+  // ADC_IRQHandler() will be called after each sample is available
+  NVIC_SetPriority(ADC_IRQn, 1);
+  NVIC_EnableIRQ(ADC_IRQn);   
+}
+
+// Called when a new sample is available from the ADC.
+// Add it to the current buffer.
+// when the buffer is full, signal that and switch to the other buffer.
+void handle_sample()
+{
+  buffers[buffer_index][sample_index++] = NRF_ADC->RESULT;
+  if (sample_index >= PACKET_SIZE)
+  {
+    sample_index = 0;
+    buffer_ready[buffer_index] = true;
+    buffer_index = (buffer_index + 1) % NUM_BUFFERS;
+    // If the next buffer is still still full, we have an overrun
+    if (buffer_ready[buffer_index])
+      Serial.println("Overrun");
+  }
+}
+
+void loop() {
+  // Wait for the adc to fill the current buffer
+  if (buffer_ready[next_tx_buffer])
+  {
+#if USE_SQUELCH
+    // Honour squelch settings
+    uint8_t min_value = 255;
+    uint8_t max_value = 0;
+    uint16_t i;
+    for (i = 0; i < PACKET_SIZE; i++)
+    {
+      if (buffers[next_tx_buffer][i] > max_value)
+        max_value = buffers[next_tx_buffer][i];
+      if (buffers[next_tx_buffer][i] < min_value)
+        min_value = buffers[next_tx_buffer][i];
+    }
+    if (max_value - min_value > SQUELCH_THRESHOLD)
+#endif
+    {
+      // OK to send this one
+      driver.waitPacketSent(); // Make sure the previous packet has gone
+      driver.send((uint8_t*)buffers[next_tx_buffer], PACKET_SIZE);
+    }
+    
+    // Now get ready to wait for the next buffer
+    buffer_ready[next_tx_buffer] = false;
+    next_tx_buffer = (next_tx_buffer + 1) % NUM_BUFFERS;
+  }
+}
+
+// Called as an interrupt after each new ADC sample is complete.
+void ADC_IRQHandler(void)
+{
+  NRF_ADC->EVENTS_END = 0; // Clear the end event
+  handle_sample();
+}
+