Creates an ADC object using the specified pin(s). The ADC object can sample a single channel or multiple channels successively if more than one pin is passed to the constructor. In this case, data from multiple channels will be interleaved in sample buffers. Additionally, the ADC channel of the first pin determines the ADC instance used, and the remaining channels (if any) must all belong to the same ADC instance.
AdvancedADC adc(analogPin);
- Pin
A0throughA11can be used.
void.
Initializes and configures the ADC with the specified parameters. To reconfigure the ADC, stop() must be called first.
adc0.begin(resolution, sample_rate, n_samples, n_buffers)
enum- resolution the sampling resolution (can be 8, 10, 12, 14 or 16 bits).AN_RESOLUTION_8AN_RESOLUTION_10AN_RESOLUTION_12AN_RESOLUTION_14AN_RESOLUTION_16
int- sample_rate - the sampling rate / frequency in Hertz, e.g.16000.int- n_samples - the number of samples per sample buffer. See SampleBuffer for more details.int- n_buffers - the number of sample buffers in the queue. See SampleBuffer for more details.bool- start - if true (the default) the ADC will start sampling immediately, otherwisestart()can be called later to start the ADC.enum- sample_time - the sampling time in cycles (the default is 8.5 cycles).AN_ADC_SAMPLETIME_1_5AN_ADC_SAMPLETIME_2_5AN_ADC_SAMPLETIME_8_5AN_ADC_SAMPLETIME_16_5AN_ADC_SAMPLETIME_32_5AN_ADC_SAMPLETIME_64_5AN_ADC_SAMPLETIME_387_5AN_ADC_SAMPLETIME_810_5
1 on success, 0 on failure.
Checks if the ADC is readable.
if(adc0.available()){}
None.
Returns true, if there's at least one sample buffer in the read queue, otherwise returns false.
Returns a sample buffer from the queue for reading.
Starts the ADC sampling.
adc.start()
1 on success, 0 on failure.
Stops the ADC and releases all of its resources.
adc.stop()
1
The AdvancedADCDual class enables the configuration of two ADCs in Dual ADC mode. In this mode, the two ADCs are synchronized, and can be sampled simultaneously, with one ADC acting as the master ADC. Note: This mode is only supported on ADC1 and ADC2, and they must be passed to begin() in that order.
AdvancedADCDual adc_dual(adc1, adc2);
AdvancedADC- adc1 - the first ADC (must be ADC1).AdvancedADC- adc2 - the second ADC (must be ADC2).
void.
Initializes and starts the two ADCs with the specified parameters.
adc_dual.begin(resolution, sample_rate, n_samples, n_buffers)
enum- resolution the sampling resolution (can be 8, 10, 12, 14 or 16 bits).AN_RESOLUTION_8AN_RESOLUTION_10AN_RESOLUTION_12AN_RESOLUTION_14AN_RESOLUTION_16
int- sample_rate - the sampling rate / frequency in Hertz, e.g.16000.int- n_samples - the number of samples per sample buffer. See SampleBuffer for more details.int- n_buffers - the number of sample buffers in the queue. See SampleBuffer for more details.enum- sample_time - the sampling time in cycles (the default is 8.5 cycles).AN_ADC_SAMPLETIME_1_5AN_ADC_SAMPLETIME_2_5AN_ADC_SAMPLETIME_8_5AN_ADC_SAMPLETIME_16_5AN_ADC_SAMPLETIME_32_5AN_ADC_SAMPLETIME_64_5AN_ADC_SAMPLETIME_387_5AN_ADC_SAMPLETIME_810_5
1 on success, 0 on failure.
Stops the dual ADCs and releases all resources.
Creates a DAC object using the specified pin.
AdvancedDAC dac0(A12);
AdvancedDAC dac1(A13);
A12orA13(DAC0 or DAC1 channels).
void.
Initializes the DAC with the specified parameters. To reconfigure the DAC, stop() must be called first. The DAC has a special mode called loop mode enabled by setting loop parameter to true. In loop mode, the DAC will start automatically after all buffers are filled, and continuously cycle through over all buffers.
dac.begin(resolution, frequency, n_samples, n_buffers, loop=false)
enum- resolution (can be 8, 10, 12 bits).AN_RESOLUTION_8AN_RESOLUTION_10AN_RESOLUTION_12
int- frequency - the output frequency in Hertz, e.g.8000.int- n_samples - the number of samples per sample buffer. See SampleBuffer for more details.int- n_buffers - the number of sample buffers in the queue. See SampleBuffer for more details.bool- loop - enables loop mode.
1 on success, 0 on failure.
Checks if the DAC is writable.
if(dac0.available()){}
None.
Returns true, if there's at least one free sample buffer in the write queue, otherwise returns false.
Returns a sample buffer from the queue for writing.
SampleBuffer buf = dac.dequeue();
for (size_t i=0; i<buf.size(); i++) {
buf[i] = SAMPLES_BUFFER[i];
}
dac1.write(buf);
Writes the sample buffer back to the DAC.
dac1.write(buf);
- A sample buffer. See SampleBuffer for more details.
Stops the DAC and releases all of its resources.
dac.stop()
1
Sets the DAC's frequency. This function can only be used after begin() has been called.
int frequency = 20000;
dac.frequency(frequency);
int- frequency in Hertz (Hz).
Creates an I2S object using the specified pins. The I2S object can be configured in input, output or full-duplex (in/out) modes to read/write PCM samples.
AdvancedI2S i2s(WS, CK, SDI, SDO, MCK);
WSI2S word select (LR clock).CKI2S bit-clock (BRCLK clock).SDII2S data input (can beNCin half-duplex output mode).SDOI2S data output (can beNCin half-duplex input mode).MCKMaster clock (can beNCif no MCLK is required).
void.
Initializes and starts the I2S device.
i2s.begin(mode, resolution, frequency, n_samples, n_buffers)
enum- mode - The I2S mode.AN_I2S_MODE_INAN_I2S_MODE_OUTAN_I2S_MODE_INOUT
int- sample_rate - The sample rate / frequency in Hertz, e.g.16000.int- n_samples - the number of samples per sample buffer. See SampleBuffer for more details.int- n_buffers - the number of sample buffers in the queue. See SampleBuffer for more details.
1 on success, 0 on failure.
Checks if the I2S is readable, writable or both (in full-duplex mode).
if(i2s.available()){}
None.
Returns true if I2S is readable, writable or both (in full-duplex mode), false if not.
Returns a sample buffer from the queue for reading. This function can be called in half-duplex input or full-duplex modes. When the buffer is no longer needed, it should be returned to I2S by calling release(), see SampleBuffer for more details.
SampleBuffer buf = i2s.read();
for (size_t i=0; i<buf.size(); i++) {
Serial.println(buf[i]);
}
i2s.release(buf);
Returns a sample buffer from the queue for writing. This function can be called in half-duplex output or full-duplex modes. When the buffer is done, it can be added to the I2S write queue by calling write() (see I2S)
SampleBuffer buf = i2s.dequeue();
for (size_t i=0; i<buf.size(); i++) {
buf[i] = SAMPLES_BUFFER[i];
}
i2s.write(buf);
Writes a sample buffer to I2S.
i2s.write(buf);
- A buffer containing the samples (see SampleBuffer).
Stops the I2S and releases all of its resources.
i2s.stop()
1
Creates a WAV file reader.
Initializes the WAV reader, opens the WAV file and reads the WAV header.
wav.begin(path, n_samples, n_buffers, loop)
string- path - the path to the WAV file.int- n_samples - the number of samples per sample buffer. See SampleBuffer for more details.int- n_buffers - the number of sample buffers in the queue. See SampleBuffer for more details.bool- *loop - if true, the WAV reader will loop back to the start of the file, when the end file is reached.
Stops the WAV file and releases all of its resources (include the WAV file handle).
Returns true if the WAV file has more data to be read.
Returns a sample buffer from the queue for reading.
If loop is false, this functions restarts the file read position.
Represents a single data item in a SampleBuffer. The Sample type is pre-defined by the library as an unsigned short (uint16_t) type.
Sample buffer objects are used throughout the library to store data samples for reading or writing. They can be used directly by the DMA, as they're cache-line-aligned, and their cache coherency is maintained by the library. The memory for sample buffers is allocated internally from memory pools and managed by the library. Each sample buffer belongs to a single memory pool, from which it was allocated, and the memory pool assigns it to the read or write queue.
SampleBuffer buf = dac.dequeue();
for (size_t i=0; i<buf.size(); i++) {
buf[i] = SAMPLES_BUFFER[i];
}
dac1.write(buf);
Returns a pointer to the buffer's internal memory. The buffer's internal memory is contiguous and can be used with memcpy, for example.
buf.data()
Returns the buffer size in samples (i.e., the number of samples in the buffer).
buf.size()
- The buffer size in samples.
Returns the buffer size in bytes (i.e., the number of samples * number of channels * sample size).
buf.bytes()
- The buffer size in bytes.
Flushes any cached data for the buffer.
buf.flush()
Invalidats any cached data for the buffer.
buf.invalidate()
Returns the timestamp of the buffer.
buf.timestamp()
- Timestamp as
int.
Returns the number of channels in the buffer.
buf.channels()
- Timestamp as
int.
This function is used internally by the library to set the buffer's flags. The flags can be one or both of two options: DMA_BUFFER_DISCONT set if the capture was stopped and then restarted, and DMA_BUFFER_INTRLVD which indicates that the data in the buffer is interleaved.
buf.setflags(uint32_t mask)
Returns true if any of the buffer flags specified in the mask argument is set. The flags can be one or both of two options: DMA_BUFFER_DISCONT set if the capture was stopped and then restarted, and DMA_BUFFER_INTRLVD which indicates that the data in the buffer is interleaved.
buf.getflags(uint32_t mask)
Returns true if any of the buffer flags specified in the mask argument is set, otherwise returns false.
Clears the buffer flags specified in the mask argument.
buf.clrflags(uint32_t mask)
void.
Releases the buffer back to its memory pool.
buf.release()