cs_ADC.h

Go to the documentation of this file.

/*
 * Author: Crownstone Team
 * Copyright: Crownstone (https://crownstone.rocks)
 * Date: 6 Nov., 2014
 * Triple-license: LGPLv3+, Apache License, and/or MIT
 */
#pragma once
 
#include <ble/cs_Nordic.h>
#include <cfg/cs_Config.h>
#include <events/cs_EventListener.h>
#include <structs/buffer/cs_AdcBuffer.h>
#include <structs/buffer/cs_CircularBuffer.h>
 
enum adc_gain_t {
    CS_ADC_GAIN4   = NRF_SAADC_GAIN4,    // gain is 4/1, maps [0, 0.15] to [0, 0.6]
    CS_ADC_GAIN2   = NRF_SAADC_GAIN2,    // gain is 2/1, maps [0, 0.3]  to [0, 0.6]
    CS_ADC_GAIN1   = NRF_SAADC_GAIN1,    // gain is 1/1, maps [0, 0.6]  to [0, 0.6]
    CS_ADC_GAIN1_2 = NRF_SAADC_GAIN1_2,  // gain is 1/2, maps [0, 1.2]  to [0, 0.6]
    CS_ADC_GAIN1_3 = NRF_SAADC_GAIN1_3,  // gain is 1/3, maps [0, 1.8]  to [0, 0.6]
    CS_ADC_GAIN1_4 = NRF_SAADC_GAIN1_4,  // gain is 1/4, maps [0, 2.4]  to [0, 0.6]
    CS_ADC_GAIN1_5 = NRF_SAADC_GAIN1_5,  // gain is 1/5, maps [0, 3.0]  to [0, 0.6]
    CS_ADC_GAIN1_6 = NRF_SAADC_GAIN1_6,  // gain is 1/6, maps [0, 3.6]  to [0, 0.6]
};
 
typedef void (*adc_done_cb_t)(adc_buffer_id_t bufIndex);
 
typedef void (*adc_zero_crossing_cb_t)();
 
// State of this class
enum adc_state_t {
    ADC_STATE_IDLE,
    ADC_STATE_BUSY,
    ADC_STATE_WAITING_TO_START,  // Wait for buffers to be released.
    ADC_STATE_READY_TO_START  // This state is a dummy, to work around the state check in start(). It is set just before
                              // calling start() again.
};
 
// State of the SAADC
enum adc_saadc_state_t {
    ADC_SAADC_STATE_IDLE,     // When saadc is idle.
    ADC_SAADC_STATE_BUSY,     // When saadc is busy sampling.
    ADC_SAADC_STATE_STOPPING  // When saadc is or will be commanded to stop.
};
 
// Max number of buffers in the SAADC peripheral.
#define CS_ADC_NUM_SAADC_BUFFERS 2
 
class ADC : EventListener {
 
public:
    static ADC& getInstance() {
        static ADC instance;
        return instance;
    }
 
    cs_ret_code_t init(const adc_config_t& config);
 
    void start();
 
    void stop();
 
    void setDoneCallback(adc_done_cb_t callback);
 
    void setZeroCrossingCallback(adc_zero_crossing_cb_t callback);
 
    void enableZeroCrossingInterrupt(adc_channel_id_t channel, int32_t zeroVal);
 
    cs_ret_code_t changeChannel(adc_channel_id_t channel, adc_channel_config_t& config);
 
    // Handle events as EventListener.
    void handleEvent(event_t& event);
 
    void _restart();
 
    void _handleAdcDone(adc_buffer_id_t bufIndex);
 
    void _handleAdcLimitInterrupt(nrf_saadc_limit_t type);
 
    void _handleAdcInterrupt();
 
private:
    ADC();
 
    // This class is singleton, deny implementation
    ADC(ADC const&);
 
    // This class is singleton, deny implementation
    void operator=(ADC const&);
 
    bool _changeConfig = false;
 
    adc_config_t _config;
 
    adc_channel_config_result_t _channelResultConfigs[CS_ADC_NUM_CHANNELS];
 
    adc_buffer_seq_nr_t _bufSeqNr = 1;
 
    nrf_ppi_channel_t _ppiChannelSample;
 
    nrf_ppi_channel_t _ppiChannelStart;
 
    CircularBuffer<adc_buffer_id_t> _bufferQueue;
 
    CircularBuffer<adc_buffer_id_t> _saadcBufferQueue;
 
    // True when next buffer is the first after start.
    bool _firstBuffer                      = true;
 
    // State of this class.
    adc_state_t _state                     = ADC_STATE_IDLE;
 
    volatile adc_saadc_state_t _saadcState = ADC_SAADC_STATE_IDLE;
 
    // Callback function
    adc_done_cb_t _doneCallback            = nullptr;
 
    inline bool dataCallbackRegistered() { return (_doneCallback != nullptr); }
 
    adc_zero_crossing_cb_t _zeroCrossingCallback = nullptr;
 
    adc_channel_id_t _zeroCrossingChannel        = 0;
 
    nrf_saadc_event_t _eventLimitLow;
 
    nrf_saadc_event_t _eventLimitHigh;
 
    bool _zeroCrossingEnabled     = false;
 
    uint32_t _lastZeroCrossUpTime = 0;
 
    int32_t _zeroValue            = 0;
 
    int _criticalRegionEntered    = 0;
 
    cs_ret_code_t initSaadc();
 
    cs_ret_code_t initChannel(adc_channel_id_t channel, adc_channel_config_t& config);
 
    // Set the adc limit such that it triggers when going above zero
    void setLimitUp();
 
    // Set the adc limit such that it triggers when going below zero
    void setLimitDown();
 
    // Initialize buffer queue
    cs_ret_code_t initBufferQueue();
 
    cs_ret_code_t fillSaadcQueue();
 
    cs_ret_code_t _fillSaadcQueue(bool fromInterrupt);
 
    cs_ret_code_t addBufferToSaadcQueue(adc_buffer_id_t bufIndex);
 
    cs_ret_code_t _addBufferToSaadcQueue(adc_buffer_id_t bufIndex);
 
    void enterCriticalRegion();
 
    void exitCriticalRegion();
 
    void printQueues();
 
    // Function to apply a new config. Should only be called when SAADC has stopped.
    void applyConfig();
 
    // Helper function that returns the adc pin number, given the AIN number.
    static nrf_saadc_input_t getAdcPin(adc_pin_id_t pinNum);
 
    // Helper function to get the ppi channel, given the index.
    static nrf_ppi_channel_t getPpiChannel(uint8_t index);
 
    // Helper function to get the limit event, given the channel.
    static nrf_saadc_event_t getLimitLowEvent(adc_channel_id_t channel);
 
    // Helper function to get the limit event, given the channel.
    static nrf_saadc_event_t getLimitHighEvent(adc_channel_id_t channel);
 
    // Helper function to get the gpiote task out, given the index.
    static nrf_gpiote_tasks_t getGpioteTaskOut(uint8_t index);
};