sensepi_cam_trigger.c

/*
 *  sensepi_cam_trigger.c : Module to handle  camera triggering related functionality
 *  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 "sensepi_cam_trigger.h"

#include "sensepi_ble.h"

#include "pir_sense.h"
#include "led_sense.h"
#include "mcp4012_x.h"
#include "ms_timer.h"
#include "led_ui.h"
#include "out_pattern_gen.h"
#include "log.h"

#include "hal_pin_analog_input.h"
#include "hal_nop_delay.h"
#include "hal_gpio.h"

#include "nrf_util.h"
#include "nrf_assert.h"
#include "common_util.h"

#include "stdint.h"
#include "stdbool.h"
#include "string.h"

#include "boards.h"
#include "sensepi_store_config.h"

#define DEBUG_PRINT 0

#define LED_WAIT_TIME_MS 301

#define PIR_SENSE_INTERVAL_MS 40

#define PIR_THRESHOLD_MULTIPLY_FACTOR 8

#define LIGHT_THRESHOLD_MULTIPLY_FACTOR 32

#define LIGHT_SENSE_INTERVAL_MS   (5*60*1000)

#define LIGHT_SENSE_INTERVAL_TICKS (MS_TIMER_TICKS_MS(LIGHT_SENSE_INTERVAL_MS))

#define SENSE_FEEDBACK_TIMEOUT_MS   (9.8*60*1000)

#define SENSE_FEEDBACK_TIMEOUT_TICKS (MS_TIMER_TICKS_MS(SENSE_FEEDBACK_TIMEOUT_MS))

#define SENSEPI_CAM_TRIGGER_MS_TIMER_USED MS_TIMER2
/*Data_Process module MACROS*/
#define NUM_PIN_OUT 2

#define SIZE_OF_BYTE 8

#define MODE_POS 0

#define INPUT1_POS 1

#define INPUT2_POS 3

#define MODE_MSK 0x000000FF

#define INPUT1_MSK 0x00FFFF00

#define INPUT2_MSK 0xFF000000

#define SINGLE_SHOT_TRANSITIONS 2

#define SINGLE_SHOT_DURATION MS_TIMER_TICKS_MS(250)

#define BULB_SHOT_TRANSITIONS 2

#define FOCUS_TRANSITIONS 2

#define TIMER_VIDEO_TRANSITIONS 3

#define VIDEO_START_PULSE MS_TIMER_TICKS_MS(250)

#define VIDEO_END_PULSE MS_TIMER_TICKS_MS(300)

#define NO_OF_VIDEO_EXTN_ALLOWED 3

#define VIDEO_PIR_ON 2000

typedef enum 
{
    MODE_SINGLE_SHOT,
    MODE_MULTISHOT,
    MODE_BULB,
    MODE_VIDEO,
    MODE_FOCUS,
    MODE_NONE,
} 
operational_mode_t;

typedef enum
{
    PIR_IDLE,
    TIMER_IDLE,
    VIDEO_IDLE,
    MAX_STATES,
}
cam_trig_state_t;
#define VIDEO_ETXN_CONFIG TIMER_IDLE

static sensepi_cam_trigger_init_config_t config;
static pir_sense_cfg config_pir;
static out_gen_config_t out_gen_config[MAX_STATES];
static uint32_t video_extn_ticks;
static bool pir_on_flag = false;
static uint32_t sense_count;
static bool sense_feedback = false;
static bool is_light_sense_on = false;
static const bool out_gen_end_all_on[OUT_GEN_MAX_NUM_OUT] = {1,1,1,1};
static const bool multishot_generic[OUT_GEN_MAX_NUM_OUT][OUT_GEN_MAX_TRANSITIONS] =
    {
            {0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1},
            {0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1},
            {0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1},
            {0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1}
    };

/*PIR related functions*/
void pir_set_state(bool state);
void pir_handler(int32_t adc_val);
void pir_handler_video(int32_t adc_val);
void out_gen_config_updater_pir(void);

/*Timer related functions*/
void timer_set_state(bool state);
void timer_handler(void);
void out_gen_config_updater_timer(void);

/*out_pattern_gen related functions*/
void out_gen_done_handler(uint32_t out_gen_state);

/*Light Sense related functions*/
void light_sense_init(void);
void light_sense_set_state(bool state);
bool light_sense_light_check(oper_time_t oper_time);

/*Module manager related function*/
//Module manager is part of program which will enable or disable the 
//PIR or timer at start event, add_ticks event and stop event
void module_manager_start_check(void);
void module_manager_disable_all(void);

void out_gen_config_single_shot(cam_trig_state_t data_process_mode);
void out_gen_config_multi_shot(cam_trig_state_t data_process_mode, 
                     uint32_t burst_duration, uint32_t burst_num);
void out_gen_config_bulb_expo(cam_trig_state_t data_process_mode, uint32_t bulb_time);
void out_gen_config_focus_only(cam_trig_state_t data_process_mode);
void out_gen_config_none(cam_trig_state_t data_process_mode);
//Suggest some good name for this function.
void out_gen_config_part_video_end();
void out_gen_config_part_video_extn(uint32_t extn_len);
void out_gen_config_part_video_start(uint32_t video_len);
void out_gen_config_full_video(cam_trig_state_t data_process_mode, uint32_t video_len);

//function definitions
void debug_print_bool_array(bool (* next)[OUT_GEN_MAX_TRANSITIONS], char * str)
{
#if DEBUG_PRINT
    log_printf("%s\n", str);
    for(uint32_t row = 0; row< NUM_PIN_OUT; row++)
    {
        for(uint32_t arr_p = 0; arr_p<OUT_GEN_MAX_TRANSITIONS; arr_p++)
        {
            log_printf("%x ", next[row][arr_p]);
        }
        log_printf("\n");
    }
    log_printf("\n");
#endif
}

void pir_set_state(bool state)
{
    log_printf("%s %x\n",__func__, state);
    if(state == true)
    {
        pir_sense_start(&config_pir);        
    }
    else
    {
        pir_sense_stop();    
    }
}

void pir_handler(int32_t adc_val)
{
    log_printf("%s", __func__);
    log_printf(" %d\n", adc_val);
    pir_set_state(false);
    if(out_gen_is_on() == false)
    {
        if(sense_feedback == true)
        {
            led_ui_single_start(LED_SEQ_PIR_PULSE, LED_UI_HIGH_PRIORITY, true);
        }
        out_gen_start(&out_gen_config[PIR_IDLE]);
    }
}

void pir_handler_video(int32_t adc_val)
{
    log_printf("%s", __func__);
    log_printf(" %d\n", adc_val);
    pir_set_state(false);
    static uint32_t no_of_extn_remain;
    if(out_gen_is_on() == false)
    {
        if(sense_feedback == true)
        {
            led_ui_single_start(LED_SEQ_PIR_PULSE, LED_UI_HIGH_PRIORITY, true);
        }
        no_of_extn_remain = NO_OF_VIDEO_EXTN_ALLOWED;
        out_gen_start(&out_gen_config[PIR_IDLE]);
    }
    else if(no_of_extn_remain > 0)
    {
        uint32_t ticks_done = out_gen_get_ticks ();
        if(ticks_done < video_extn_ticks)
        {
            out_gen_config[VIDEO_ETXN_CONFIG].transitions_durations[0] = 
                (video_extn_ticks  - ticks_done);
        }
        else
        {
            out_gen_config[VIDEO_ETXN_CONFIG].transitions_durations[0] = 
                video_extn_ticks;
        }
        out_gen_start(&out_gen_config[VIDEO_ETXN_CONFIG]);
        no_of_extn_remain--;
    }
}

void out_gen_config_updater_pir()
{
    uint32_t config_mode = config.config_sensepi->pir_conf.mode;
    uint32_t mode = ((config_mode & MODE_MSK) 
            >> (MODE_POS * SIZE_OF_BYTE));
    uint32_t input1 = ((config_mode & INPUT1_MSK) 
            >> (INPUT1_POS * SIZE_OF_BYTE));
    uint32_t input2 = ((config_mode & INPUT2_MSK) 
            >> (INPUT2_POS * SIZE_OF_BYTE));
    uint32_t single_input = config_mode>> (INPUT1_POS * SIZE_OF_BYTE);
    switch((operational_mode_t)mode)
    {
        case MODE_SINGLE_SHOT:
        {
            out_gen_config_single_shot(PIR_IDLE);
            break;
        }
        case MODE_MULTISHOT:
        {
            out_gen_config_multi_shot(PIR_IDLE, input1, input2);
            break;
        }
        case MODE_BULB :
        {
            //Using both input 1 and input 2
            out_gen_config_bulb_expo(PIR_IDLE, single_input);
            break;
        }
        case MODE_VIDEO :
        {
            if(input2 == 0)
            {
                out_gen_config_full_video (PIR_IDLE, input1);
            }
            else
            {
                out_gen_config_part_video_start(input1);
                out_gen_config_part_video_extn(input2);
                out_gen_config_part_video_end(input2);
            }
            break;
        }
        case MODE_FOCUS :
        {
            out_gen_config_focus_only(PIR_IDLE);
            break;
        }
        case MODE_NONE:
        {
            out_gen_config_none(PIR_IDLE);
        }
    }   
}

void timer_set_state(bool state)
{
    if(state == true)
    {
        if(ms_timer_get_on_status (SENSEPI_CAM_TRIGGER_MS_TIMER_USED) == false)
        {
            ms_timer_start(SENSEPI_CAM_TRIGGER_MS_TIMER_USED, MS_REPEATED_CALL,
               MS_TIMER_TICKS_MS(config.config_sensepi->timer_conf.timer_interval * 100),
               timer_handler);
        }
    }
    else
    {
        ms_timer_stop(SENSEPI_CAM_TRIGGER_MS_TIMER_USED);
    }
}

void timer_handler()
{
    if(out_gen_is_on () == false)
    {
        out_gen_start(&out_gen_config[TIMER_IDLE]);
    }
}

void out_gen_config_updater_timer(void)
{
    uint32_t config_mode = config.config_sensepi->timer_conf.mode;
    uint32_t mode = ((config_mode & MODE_MSK) 
            >> (MODE_POS * SIZE_OF_BYTE));
    uint32_t input1 = ((config_mode & INPUT1_MSK) 
            >> (INPUT1_POS * SIZE_OF_BYTE));
    uint32_t input2 = ((config_mode & INPUT2_MSK) 
            >> (INPUT2_POS * SIZE_OF_BYTE));
    uint32_t single_input = config_mode>> (INPUT1_POS * SIZE_OF_BYTE);
    switch((operational_mode_t)mode)
    {
        case MODE_SINGLE_SHOT:
        {
            out_gen_config_single_shot(TIMER_IDLE);
            break;
        }
        case MODE_MULTISHOT:
        {
            out_gen_config_multi_shot(TIMER_IDLE, input1, input2);
            break;
        }
        case MODE_BULB :
        {
            //Using both input 1 and input 2
            out_gen_config_bulb_expo(TIMER_IDLE, single_input);
            break;
        }
        case MODE_VIDEO :
        {
            out_gen_config_full_video(TIMER_IDLE,input1);
            break;
        }
        case MODE_FOCUS :
        {
            out_gen_config_focus_only(TIMER_IDLE);
            break;
        }
        case MODE_NONE:
        {
            out_gen_config_none(PIR_IDLE);
        }
    }   
}

void out_gen_done_handler (uint32_t out_gen_state)
{
    log_printf("%s",__func__);
    log_printf(" %d\n", out_gen_state);
    switch((cam_trig_state_t)out_gen_state)
    {
        case PIR_IDLE :
        {
            pir_set_state(pir_on_flag);
            break;
        }
        case TIMER_IDLE : 
        {
            if(config.config_sensepi->trig_conf == PIR_AND_TIMER)
            {
                pir_set_state(pir_on_flag);
            }
            break;
        }
        case VIDEO_IDLE :
        {
            out_gen_start(&out_gen_config[VIDEO_IDLE]);
            pir_set_state(pir_on_flag);
            break;
        }
        case MAX_STATES : 
        {
            log_printf("Something went seriously wrong..!!\n");
            break;
        }
    }
}

void light_sense_init(void)
{
    log_printf("%s\n",__func__);
    led_sense_init (config.led_sense_out_pin,
                    config.led_sense_analog_in_pin,
                    config.led_sense_off_val);
}

void light_sense_set_state(bool state)
{
    if(state == true)
    {
        led_sense_cfg_input(true);
        //To make sure that the green LED is ready to sense light
        hal_nop_delay_ms(LED_WAIT_TIME_MS);
    }
    else
    {
        led_sense_cfg_input(false);
    }
}

bool light_sense_light_check(oper_time_t oper_time)
{
    log_printf("%d\n", __func__);

    uint8_t light_sense_config = oper_time.day_or_night;
    uint32_t light_threshold =
            (uint32_t)((oper_time.threshold) * LIGHT_THRESHOLD_MULTIPLY_FACTOR);

    uint32_t light_intensity = led_sense_get();
    log_printf("Light Intensity : %d\n", light_intensity);

    static bool light_check_flag = 0;
    //Day and its brighter than the threshold
    if(((light_sense_config == 1) && (light_intensity >= light_threshold))
            ||  //Night and its dimmer than the threshold
       ((light_sense_config == 0) && (light_intensity <= light_threshold)))
    {
        light_check_flag = 1;
    }
    else
    {
        light_check_flag = 0;
    }
    return light_check_flag;
}

void module_manager_start_check(void)
{
    log_printf("%s\n", __func__);
    //Switch off PIR module so that light sensing can happen
    pir_set_state(false);
    bool light_flag;
    switch(config.config_sensepi->trig_conf)
    {
        case PIR_ONLY : 
        {
            light_flag = light_sense_light_check(config.config_sensepi->pir_conf.oper_time);
            pir_on_flag = light_flag;
            pir_set_state(light_flag);
            
            break;
        }
        case TIMER_ONLY : 
        {
            light_flag = light_sense_light_check(config.config_sensepi->timer_conf.oper_time);
            timer_set_state(light_flag);
                    
            break;
        }
        case PIR_AND_TIMER :
        {
            light_flag = light_sense_light_check(config.config_sensepi->pir_conf.oper_time);
            pir_on_flag = light_flag;

            light_flag = light_sense_light_check(config.config_sensepi->timer_conf.oper_time);
            timer_set_state(light_flag);
            pir_set_state(pir_on_flag);

            break;
        }
    }

}

void module_manager_disable_all(void)
{
    pir_set_state(false);
    timer_set_state(false);
    light_sense_set_state(false);
}

void out_gen_config_single_shot(cam_trig_state_t data_process_mode)
{
    log_printf("%s\n", __func__);
    uint32_t number_of_transition = SINGLE_SHOT_TRANSITIONS;
    int32_t time_remain;

    if(data_process_mode == PIR_IDLE)
    {
        time_remain = MS_TIMER_TICKS_MS(config.config_sensepi->pir_conf.intr_trig_timer * 100) 
            - (SINGLE_SHOT_DURATION); 
        if((int32_t)time_remain <= 0)
        {
            time_remain = 0;
        }
    }
    else if(data_process_mode == TIMER_IDLE)
    {
        time_remain = 0;
    }

    out_gen_config_t local_out_gen_config = 
    {
        .num_transitions = number_of_transition,
        .done_handler = out_gen_done_handler,
        .out_gen_state = data_process_mode,
        .transitions_durations = { SINGLE_SHOT_DURATION, time_remain },
        .next_out = {{0, 1, 1},
                     {0, 1, 1}},
    };

    debug_print_bool_array(local_out_gen_config.next_out, "single shot");
    memcpy(&out_gen_config[data_process_mode],&local_out_gen_config,
           sizeof(out_gen_config_t));
}

void out_gen_config_multi_shot(cam_trig_state_t data_process_mode, 
                     uint32_t burst_duration, uint32_t burst_num)
{
    log_printf("%s\n", __func__);
    int32_t time_remain;
    uint32_t number_of_transition = SINGLE_SHOT_TRANSITIONS * burst_num;
    //Time for trigger pulse and time till next trigger for each burst
    uint32_t repeat_delay_array[SINGLE_SHOT_TRANSITIONS] = {SINGLE_SHOT_DURATION,
            MS_TIMER_TICKS_MS(burst_duration * 100) - SINGLE_SHOT_DURATION};
    out_gen_config_t local_out_gen_config = 
    {
        .num_transitions = number_of_transition,
        .done_handler = out_gen_done_handler,
        .out_gen_state = data_process_mode,
    };

    for(uint32_t i = 0; i< burst_num; i++)
    {
        memcpy(local_out_gen_config.transitions_durations + i*SINGLE_SHOT_TRANSITIONS,
                repeat_delay_array, SINGLE_SHOT_TRANSITIONS*sizeof(uint32_t));

        for(uint32_t j = 0; j < NUM_PIN_OUT; j++)
        {
            memcpy(*(local_out_gen_config.next_out +j),*(multishot_generic + j),
                    burst_num* SINGLE_SHOT_TRANSITIONS*sizeof(bool));
            //An extra '1' at the end for the remaining of the inter-trigger time
            local_out_gen_config.next_out[j][burst_num* SINGLE_SHOT_TRANSITIONS] = 1;
        }
    }

    if(data_process_mode == PIR_IDLE)
    {
        time_remain = MS_TIMER_TICKS_MS(config.config_sensepi->pir_conf.intr_trig_timer * 100)
            - SINGLE_SHOT_DURATION*burst_num -
            (MS_TIMER_TICKS_MS(burst_duration * 100) - SINGLE_SHOT_DURATION)*(burst_num - 1);  
        if((int32_t)time_remain <= 0)
        {
            time_remain = 1;
        }
   }
    else if(data_process_mode == TIMER_IDLE)
    {
        time_remain = 1;
    }
    // Last interval for the '1' signal till 'time till next trigger' elapses
    local_out_gen_config.transitions_durations[number_of_transition-1] = time_remain;
            

    debug_print_bool_array(local_out_gen_config.next_out, "multi shot");
    memcpy(&out_gen_config[data_process_mode], &local_out_gen_config,
           sizeof(out_gen_config_t));
}

void out_gen_config_bulb_expo(cam_trig_state_t data_process_mode, uint32_t bulb_time)
{
    log_printf("%s\n", __func__);
    int32_t time_remain;
    uint32_t number_of_transition = BULB_SHOT_TRANSITIONS;
    uint32_t bulb_time_ticks = MS_TIMER_TICKS_MS((bulb_time*100));

    if(data_process_mode == PIR_IDLE)
    {
        time_remain = MS_TIMER_TICKS_MS(config.config_sensepi->pir_conf.intr_trig_timer * 100)
            - bulb_time_ticks ;
        if((int32_t)time_remain <= 0)
        {
            time_remain = 1;
        }
    }
    else if(data_process_mode == TIMER_IDLE)
    {
        time_remain = 0;
    }

    out_gen_config_t local_out_gen_config = 
    {
        .num_transitions = number_of_transition,
        .done_handler = out_gen_done_handler,
        .out_gen_state = data_process_mode,
        .transitions_durations = 
            {bulb_time_ticks, time_remain},
        .next_out = { {0, 1, 1},
                      {0, 1, 1} },
    };

    debug_print_bool_array(local_out_gen_config.next_out, "bulb mode");
    memcpy(&out_gen_config[data_process_mode],&local_out_gen_config,
           sizeof(out_gen_config_t));
}

void out_gen_config_full_video(cam_trig_state_t data_process_mode, uint32_t video_len)
{
    int32_t time_remain;
    video_len = video_len*1000;
    if(data_process_mode == TIMER_IDLE)
    {
        time_remain = config.config_sensepi->timer_conf.timer_interval*100 -
            video_len - VIDEO_START_PULSE -VIDEO_END_PULSE;
    }
    video_len = (time_remain < 0) ?
        (config.config_sensepi->timer_conf.timer_interval*100 - 1000) :
        video_len;
    out_gen_config_t local_out_gen_config =
    {
        .num_transitions = TIMER_VIDEO_TRANSITIONS,
        .next_out = {{0,1,0,1},
            {1,1,1,1}},
        .transitions_durations = {VIDEO_START_PULSE,
                    MS_TIMER_TICKS_MS(video_len),
                    VIDEO_END_PULSE},
        .done_handler = out_gen_done_handler,
        .out_gen_state = data_process_mode,

    };
    debug_print_bool_array(local_out_gen_config.next_out, "Timer video mode");
    memcpy(&out_gen_config[data_process_mode],&local_out_gen_config,
           sizeof(out_gen_config_t));

   
}

void out_gen_config_part_video_start(uint32_t video_len)
{
    config_pir.handler = pir_handler_video;
    video_len = video_len * 1000;
    int video_len_check = video_len  - VIDEO_PIR_ON;
    video_len = (video_len_check <= 0) ? 0 : video_len_check;
    out_gen_config_t local_out_gen_config =
    {
        .num_transitions = SINGLE_SHOT_TRANSITIONS,
        .next_out = {{0,1,1}
        ,{1,1,1}},
        .transitions_durations = {VIDEO_START_PULSE, 
                                    (MS_TIMER_TICKS_MS(video_len))},
        .done_handler = out_gen_done_handler,
        .out_gen_state = VIDEO_IDLE,
    };
    debug_print_bool_array(local_out_gen_config.next_out, "PIR video mode");
    memcpy(&out_gen_config[PIR_IDLE],&local_out_gen_config,
           sizeof(out_gen_config_t));    
}

void out_gen_config_part_video_extn (uint32_t extn_len)
{
    video_extn_ticks = MS_TIMER_TICKS_MS(extn_len * 1000);
    out_gen_config_t local_out_gen_config = 
    {
        .num_transitions = 1,
        .next_out = {{1,1}, {1,1}},
        .transitions_durations = {video_extn_ticks},
        .done_handler = out_gen_done_handler,
        .out_gen_state = VIDEO_IDLE,
    };
    debug_print_bool_array(local_out_gen_config.next_out, "PIR video extension");
    memcpy(&out_gen_config[VIDEO_ETXN_CONFIG],&local_out_gen_config,
           sizeof(out_gen_config_t));    
    
}

void out_gen_config_part_video_end()
{
    out_gen_config_t local_out_gen_config = 
    {
        .num_transitions = SINGLE_SHOT_TRANSITIONS,
        .next_out = {{1,0,1},
            {1,1,1}},
        .transitions_durations = {MS_TIMER_TICKS_MS(VIDEO_PIR_ON), VIDEO_END_PULSE,},
        .done_handler = out_gen_done_handler,
        .out_gen_state = PIR_IDLE,
    };
    debug_print_bool_array(local_out_gen_config.next_out, "PIR video mode");
    memcpy(&out_gen_config[VIDEO_IDLE],&local_out_gen_config,
           sizeof(out_gen_config_t)); 
}

void out_gen_config_focus_only(cam_trig_state_t data_process_mode)
{
    log_printf("%s\n", __func__);
    int32_t time_remain;
    uint32_t number_of_transition = FOCUS_TRANSITIONS;

    if(data_process_mode == PIR_IDLE)
    {
        time_remain =  MS_TIMER_TICKS_MS(config.config_sensepi->pir_conf.intr_trig_timer * 100)
            - SINGLE_SHOT_DURATION ;
        if((int32_t)time_remain <= 0)
        {
            time_remain = 1;
        }
    }
    else if(data_process_mode == TIMER_IDLE)
    {
        time_remain = 1;
    }

    out_gen_config_t local_out_gen_config = 
    {
        .num_transitions = number_of_transition,
        .done_handler = out_gen_done_handler,
        .out_gen_state = data_process_mode,
        .transitions_durations =
        {SINGLE_SHOT_DURATION ,time_remain},
        .next_out = { {0, 1, 1},
                      {1, 1, 1} },
    };
    
    debug_print_bool_array(local_out_gen_config.next_out, "focus mode");
    memcpy(&out_gen_config[data_process_mode],&local_out_gen_config,
           sizeof(out_gen_config_t));
}

void out_gen_config_none(cam_trig_state_t data_process_mode)
{
    out_gen_config_t local_out_gen_config =
    {
        .num_transitions = 1,
        .done_handler = out_gen_done_handler,
        .out_gen_state = data_process_mode,
        .transitions_durations = {1},
        .next_out = { {1},
                      {1} },
    };

    memcpy(&out_gen_config[data_process_mode],&local_out_gen_config,
           sizeof(out_gen_config_t));
}

void sensepi_cam_trigger_init(sensepi_cam_trigger_init_config_t * config_sensepi_cam_trigger)
{
    log_printf("%s\n", __func__);
    ASSERT(config_sensepi_cam_trigger->signal_pin_num == NUM_PIN_OUT);
    memcpy(&config, config_sensepi_cam_trigger, sizeof(config));
    light_sense_init();
    mcp4012_init(config.amp_cs_pin, config.amp_ud_pin, config.amp_spi_sck_pin);
    pir_sense_cfg local_config_pir = 
    {
        PIR_SENSE_INTERVAL_MS, config.pir_sense_signal_input,
        config.pir_sense_offset_input,
        ((uint32_t)config.config_sensepi->pir_conf.threshold)*PIR_THRESHOLD_MULTIPLY_FACTOR,
        APP_IRQ_PRIORITY_HIGH, pir_handler, 
    };
    memcpy(&config_pir, &local_config_pir, sizeof(pir_sense_cfg));
    out_gen_init(NUM_PIN_OUT, config.signal_out_pin_array, 
                 (bool *) out_gen_end_all_on);
}

void sensepi_cam_trigger_update(sensepi_config_t * update_config)
{
    log_printf("%s\n", __func__);
    memcpy(config.config_sensepi, update_config, sizeof(sensepi_config_t));
}

void sensepi_cam_trigger_start()
{
    log_printf("%s\n", __func__);

    if(memcmp (config.config_sensepi, sensepi_store_config_get_last_config(),
               sizeof(sensepi_config_t)) != 0)
    {
        sensepi_store_config_write (config.config_sensepi);
    }
    sense_count = 0;
    sense_feedback = true;
    oper_time_t pir_oper_time = config.config_sensepi->pir_conf.oper_time;
    oper_time_t timer_oper_time = config.config_sensepi->timer_conf.oper_time;
    bool pir_light_flag = true;
    bool timer_light_flag = true;
    if(config.config_sensepi->trig_conf != PIR_ONLY)
    {
        if((timer_oper_time.day_or_night == 1 && timer_oper_time.threshold == 0b0000000)||
        (timer_oper_time.day_or_night == 0 && timer_oper_time.threshold == 0b1111111))
        {
            timer_light_flag = false;
        }
        else
        {
            timer_light_flag = true;
        }      
    }
    else
    {
        timer_light_flag = false;
    }
    if(config.config_sensepi->trig_conf != TIMER_ONLY)
    {
        if((pir_oper_time.day_or_night == 1 && pir_oper_time.threshold == 0b0000000)||
        (pir_oper_time.day_or_night == 0 && pir_oper_time.threshold == 0b1111111))
        {
            pir_light_flag = false;
        }
        else
        {
            pir_light_flag = true;
        }      
    }
    else
    {
        pir_light_flag = false;
    }
    is_light_sense_on = pir_light_flag || timer_light_flag; 

    config_pir.threshold = ((uint32_t) config.config_sensepi->pir_conf.threshold)
            *PIR_THRESHOLD_MULTIPLY_FACTOR;
    config_pir.handler = pir_handler;

    mcp4012_set_value(config.config_sensepi->pir_conf.amplification);

    out_gen_config_updater_timer();
    out_gen_config_updater_pir();

    light_sense_set_state(true);
    module_manager_start_check();
}

void sensepi_cam_trigger_add_tick(uint32_t interval)
{
    static uint32_t light_sense_count = 0;

    log_printf("%s\n", __func__);
    log_printf("SensePi Add ticks : %d\n", interval);

    sense_count += interval;
    if(sense_count > SENSE_FEEDBACK_TIMEOUT_TICKS)
    {
        sense_feedback = false;
    }

    light_sense_count += interval;
    if(light_sense_count > LIGHT_SENSE_INTERVAL_TICKS && sense_feedback == false
       && is_light_sense_on == true)
    {
        module_manager_start_check();
        light_sense_count = (light_sense_count - LIGHT_SENSE_INTERVAL_TICKS);
    }
}

void sensepi_cam_trigger_stop()
{
    log_printf("%s\n",__func__);
    module_manager_disable_all();
    out_gen_stop((bool *) out_gen_end_all_on);
    led_ui_type_stop_all(LED_UI_SINGLE_SEQ);
}

sensepi_config_t * sensepi_cam_trigger_get_sensepi_config()
{
    log_printf("%s\n", __func__);
    return (config.config_sensepi);
}