main.c

/*
 *  main.c : Application to log ADC values
 *  Copyright (C) 2019  Appiko
 *
 *  This program is free software: you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation, either version 3 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *  
 *  You should have received a copy of the GNU General Public License
 *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
 */

#include <stdbool.h>
#include <stdint.h>

#include "nrf.h"

#include "boards.h"
#include "hal_saadc.h"
#include "hal_clocks.h"
#include "hal_nop_delay.h"
#include "hal_gpio.h"
#include "nrf_assert.h"
#include "hal_nop_delay.h"
#include "ms_timer.h"
#include "common_util.h"
#include "nrf_util.h"
#include "log.h"

/*      Defines         */
#define LOGGER_INTERVAL_MS          50

#define SAADC_NUMBER_OF_CHANNELS    1

#if 0
#define SAADC_RC_CHANNEL_CONFIG                      \
    {                                                  \
        .resistor_p = NRF_SAADC_RESISTOR_DISABLED,     \
        .resistor_n = NRF_SAADC_RESISTOR_DISABLED,     \
        .gain       = NRF_SAADC_GAIN4,                 \
        .reference  = NRF_SAADC_REFERENCE_INTERNAL,    \
        .acq_time   = NRF_SAADC_ACQTIME_10US,          \
        .mode       = NRF_SAADC_MODE_DIFFERENTIAL,     \
        .burst      = NRF_SAADC_BURST_ENABLED,         \
        .pin_p      = PIN_TO_ANALOG_INPUT(PIR_RC_SIGNAL_PIN),      \
        .pin_n      = PIN_TO_ANALOG_INPUT(PIR_RC_OFFSET_PIN)       \
    }
#else
#define SAADC_AMP_CHANNEL_CONFIG                    \
    {                                                  \
        .resistor_p = NRF_SAADC_RESISTOR_DISABLED,     \
        .resistor_n = NRF_SAADC_RESISTOR_DISABLED,     \
        .gain       = NRF_SAADC_GAIN1,                 \
        .reference  = NRF_SAADC_REFERENCE_INTERNAL,    \
        .acq_time   = NRF_SAADC_ACQTIME_10US,          \
        .mode       = NRF_SAADC_MODE_DIFFERENTIAL,     \
        .burst      = NRF_SAADC_BURST_DISABLED,         \
        .pin_p      = PIN_TO_ANALOG_INPUT(PIR_AMP_SIGNAL_PIN),      \
        .pin_n      = PIN_TO_ANALOG_INPUT(PIR_AMP_OFFSET_PIN)       \
    }

#endif

#define PIR_RC_CHANNEL_UPPER_LIMIT      (32767)
#define PIR_RC_CHANNEL_LOWER_LIMIT      (-32768)

#define PIR_AMP_CHANNEL_UPPER_LIMIT    (100)
#define PIR_AMP_CHANNEL_LOWER_LIMIT    (-100)

#define APPLN_SAADC_RESOLUTION    NRF_SAADC_RESOLUTION_12BIT

#define APPLN_SAADC_OVERSAMPLING  NRF_SAADC_OVERSAMPLE_DISABLED

#define APPLN_SAADC_IRQ_PRIORITY  APP_IRQ_PRIORITY_LOW

struct saadc_limit
{
    int16_t upper_limit;
    int16_t lower_limit;
};


/*      Global constants in flash         */
static const struct saadc_limit saadc_limit_config[SAADC_NUMBER_OF_CHANNELS] =
{
//        { PIR_RC_CHANNEL_UPPER_LIMIT, PIR_RC_CHANNEL_LOWER_LIMIT }
        { PIR_AMP_CHANNEL_UPPER_LIMIT, PIR_AMP_CHANNEL_LOWER_LIMIT }
};

static const nrf_saadc_channel_config_t saadc_ch_config[SAADC_NUMBER_OF_CHANNELS] =
    {
//            SAADC_RC_CHANNEL_CONFIG
            SAADC_AMP_CHANNEL_CONFIG
    };

/*      Globals        */
static int16_t saadc_result[1];

/*      Function declarations        */
static void saadc_init(void);


void trigger_handler(void)
{
    log_printf("RTC handlers\n");
    hal_gpio_pin_toggle(LED_RED);
}


/*      Function definitions        */
void SAADC_IRQHandler(void)
{
#if 0
    if(nrf_saadc_event_check(NRF_SAADC_EVENT_STARTED))
    {
        nrf_saadc_event_clear(NRF_SAADC_EVENT_STARTED);
        SEGGER_RTT_printf(0, "STARTED: %d\n", saadc_result);
    }

#endif
#if 1
    if (nrf_saadc_event_check(NRF_SAADC_EVENT_END))
    {
        nrf_saadc_event_clear(NRF_SAADC_EVENT_END);

        log_printf("END: %d [%d%d]\n", saadc_result[0], NRF_SAADC->EVENTS_CH[0].LIMITH, NRF_SAADC->EVENTS_CH[0].LIMITL
//                ,saadc_result[1], NRF_SAADC->EVENTS_CH[1].LIMITH, NRF_SAADC->EVENTS_CH[1].LIMITL
                );
//        if(NRF_SAADC->EVENTS_CH[0].LIMITH){
//            SEGGER_RTT_printf(0, "END 0: %d\n", saadc_result[0]);
//        } else if (NRF_SAADC->EVENTS_CH[1].LIMITH){
//            SEGGER_RTT_printf(0, "END 1: %d\n", saadc_result[0]);
//        }

        NRF_SAADC->EVENTS_CH[0].LIMITH = NRF_SAADC->EVENTS_CH[0].LIMITL = 0;
        NRF_SAADC->EVENTS_CH[1].LIMITH = NRF_SAADC->EVENTS_CH[1].LIMITL = 0;
    }
#endif
#if 0

    if(nrf_saadc_event_check(NRF_SAADC_EVENT_DONE))
    {
        nrf_saadc_event_clear(NRF_SAADC_EVENT_DONE);
        SEGGER_RTT_printf(0, "DONE: %d\n", saadc_result);
    }

    if(nrf_saadc_event_check(NRF_SAADC_EVENT_RESULTDONE))
    {
        nrf_saadc_event_clear(NRF_SAADC_EVENT_RESULTDONE);
        SEGGER_RTT_printf(0, "RESULTDONE: %d\n", saadc_result);
    }

    if(nrf_saadc_event_check(NRF_SAADC_EVENT_STOPPED))
    {
        nrf_saadc_event_clear(NRF_SAADC_EVENT_STOPPED);
        SEGGER_RTT_printf(0, "STOPPED: %d %d\n", saadc_result[0], saadc_result[1]);
        nrf_saadc_disable();
    }
#endif
#if 1
    if(nrf_saadc_event_check(NRF_SAADC_EVENT_CH0_LIMITH))
    {
        nrf_saadc_event_clear(NRF_SAADC_EVENT_CH0_LIMITH);
        log_printf("CH0_LIMITH: %d\n", saadc_result[0]);
//        SEGGER_RTT_printf(0, "CH0_LIMITH: %d\n", saadc_result[0]);
//        ms_timer_start(MS_TIMER3,MS_SINGLE_CALL, RTC_TICKS_MS(49), trigger_handler);
//        hal_gpio_pin_write(LED_RED, LEDS_ACTIVE_STATE);
    }
    if(nrf_saadc_event_check(NRF_SAADC_EVENT_CH0_LIMITL))
    {
        nrf_saadc_event_clear(NRF_SAADC_EVENT_CH0_LIMITL);
        log_printf("CH0_LIMITL: %d\n", saadc_result[0]);
//        SEGGER_RTT_printf(0, "CH0_LIMITL: %d\n", saadc_result[0]);
//        ms_timer_start(MS_TIMER3,MS_SINGLE_CALL, RTC_TICKS_MS(49), trigger_handler);
//        hal_gpio_pin_write(LED_RED, LEDS_ACTIVE_STATE);
    }
#endif
#if 0
    if(nrf_saadc_event_check(NRF_SAADC_EVENT_CH1_LIMITH))
    {
        nrf_saadc_event_clear(NRF_SAADC_EVENT_CH1_LIMITH);
        SEGGER_RTT_printf(0, "CH1_LIMITH: %d %d\n", saadc_result[0], saadc_result[1]);
    }

    if(nrf_saadc_event_check(NRF_SAADC_EVENT_CH1_LIMITL))
    {
        nrf_saadc_event_clear(NRF_SAADC_EVENT_CH1_LIMITL);
        SEGGER_RTT_printf(0, "CH1_LIMITL: %d %d\n", saadc_result[0], saadc_result[1]);
    }
#endif
}


static void saadc_init(void)
{
    static_assert((SAADC_NUMBER_OF_CHANNELS > 0) && (SAADC_NUMBER_OF_CHANNELS <= 8),
            "The number of SAADC channels is between 1 and 8");
    static_assert((PIR_AMP_CHANNEL_LOWER_LIMIT >= -32768) && (PIR_AMP_CHANNEL_LOWER_LIMIT <= 32767),
            "The channel limit of SAADC is between -32768 and 32767");
    static_assert((PIR_AMP_CHANNEL_UPPER_LIMIT >= -32768) && (PIR_AMP_CHANNEL_UPPER_LIMIT <= 32767),
            "The channel limit of SAADC is between -32768 and 32767");
    static_assert((PIR_RC_CHANNEL_LOWER_LIMIT >= -32768) && (PIR_RC_CHANNEL_LOWER_LIMIT <= 32767),
            "The channel limit of SAADC is between -32768 and 32767");
    static_assert((PIR_RC_CHANNEL_UPPER_LIMIT >= -32768) && (PIR_RC_CHANNEL_UPPER_LIMIT <= 32767),
            "The channel limit of SAADC is between -32768 and 32767");

    nrf_saadc_resolution_set(APPLN_SAADC_RESOLUTION);
    saadc_sampling_task_mode_set();
    nrf_saadc_buffer_init(saadc_result, ARRAY_SIZE(saadc_result));
    NVIC_SetPriority(SAADC_IRQn, APPLN_SAADC_IRQ_PRIORITY);
    NVIC_EnableIRQ(SAADC_IRQn);
    NVIC_ClearPendingIRQ(SAADC_IRQn);
    nrf_saadc_oversample_set(APPLN_SAADC_OVERSAMPLING);

    for (uint32_t i = 0; i < SAADC_NUMBER_OF_CHANNELS; i++)
    {
        saadc_channel_init(i, &saadc_ch_config[i]);
        nrf_saadc_channel_limits_set(i,
                saadc_limit_config[i].lower_limit,
                saadc_limit_config[i].upper_limit);
    }

    nrf_saadc_int_enable(
                         NRF_SAADC_INT_END |
                         NRF_SAADC_INT_CH0LIMITH |
                         NRF_SAADC_INT_CH0LIMITL
//                         NRF_SAADC_INT_CH1LIMITH |
//                         NRF_SAADC_INT_CH1LIMITL
                         );

    NRF_PPI->CH[PPI_CHEN_CH0_Pos].EEP = (uint32_t) &(NRF_SAADC->EVENTS_STARTED);
    NRF_PPI->CH[PPI_CHEN_CH0_Pos].TEP = (uint32_t) &(NRF_SAADC->TASKS_SAMPLE);
    NRF_PPI->CHENSET = PPI_CHENSET_CH0_Set << PPI_CHEN_CH0_Pos;

//    nrf_ppi_channel_endpoint_setup(NRF_PPI_CHANNEL0,
//            nrf_saadc_event_address_get(NRF_SAADC_EVENT_STARTED),
//            nrf_saadc_task_address_get(NRF_SAADC_TASK_SAMPLE));
//    nrf_ppi_channel_enable(NRF_PPI_CHANNEL0);

    NRF_PPI->CH[PPI_CHEN_CH1_Pos].EEP = (uint32_t) &(NRF_RTC0->EVENTS_COMPARE[0]);
    NRF_PPI->CH[PPI_CHEN_CH1_Pos].TEP = (uint32_t) &(NRF_SAADC->TASKS_START);
    NRF_PPI->FORK[PPI_CHEN_CH1_Pos].TEP = (uint32_t) &(NRF_RTC0->TASKS_CLEAR);
    NRF_PPI->CHENSET = PPI_CHENSET_CH1_Set << PPI_CHEN_CH1_Pos;

//    nrf_ppi_channel_endpoint_setup(NRF_PPI_CHANNEL1,
//            nrf_rtc_event_address_get(NRF_RTC0, NRF_RTC_EVENT_COMPARE_0),
//            nrf_saadc_task_address_get(NRF_SAADC_TASK_START));
//    nrf_ppi_fork_endpoint_setup(NRF_PPI_CHANNEL1,
//            nrf_rtc_task_address_get(NRF_RTC0, NRF_RTC_TASK_CLEAR));
//    nrf_ppi_channel_enable(NRF_PPI_CHANNEL1);

    NRF_PPI->CH[PPI_CHEN_CH2_Pos].EEP = (uint32_t) &(NRF_SAADC->EVENTS_END);
    NRF_PPI->CH[PPI_CHEN_CH2_Pos].TEP = (uint32_t) &(NRF_SAADC->TASKS_STOP);
    NRF_PPI->CHENSET = PPI_CHENSET_CH2_Set << PPI_CHEN_CH2_Pos;

//    nrf_ppi_channel_endpoint_setup(NRF_PPI_CHANNEL2,
//            nrf_saadc_event_address_get(NRF_SAADC_EVENT_END),
//            nrf_saadc_task_address_get(NRF_SAADC_TASK_STOP));
//    nrf_ppi_channel_enable(NRF_PPI_CHANNEL2);

    NRF_RTC0->TASKS_STOP = 1;
    NRF_RTC0->PRESCALER = 0;
    NRF_RTC0->CC[0] = RTC_TICKS_MS(LOGGER_INTERVAL_MS);
    NRF_RTC0->EVTENSET = (RTC_EVTENSET_COMPARE0_Enabled << RTC_EVTENSET_COMPARE0_Pos);
    NRF_RTC0->EVENTS_COMPARE[0] = 0;
    NRF_RTC0->TASKS_START = 1;
    nrf_saadc_enable();
}


int main(void)
{
    /* Mandatory welcome message */
    log_init();
    log_printf("\n\nHello World!\n");

    lfclk_init(LFCLK_SRC_Xtal);

    saadc_init();

    while (true)
    {
        __WFI();
    }
}