rocketloggerd.c

Go to the documentation of this file.

 
#include <errno.h>
#include <stdint.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
 
#include <signal.h>
#include <sys/reboot.h>
#include <unistd.h>
 
#include "gpio.h"
#include "log.h"
#include "rl.h"
#include "rl_lib.h"
 
#define RL_DAEMON_MIN_INTERVAL 1
 
#define RL_CALIBRATION_DURATION_SEC 1
 
#define RL_POWERUP_DELAY_US 5000
 
#define RL_BUTTON_LONG_PRESS_SEC 3
 
#define RL_BUTTON_VERY_LONG_PRESS_SEC 6
 
#define RL_BUTTON_EXTRA_LONG_PRESS_SEC 10
 
enum system_action {
    SYSTEM_ACTION_NONE,     
    SYSTEM_ACTION_REBOOT,   
    SYSTEM_ACTION_POWEROFF, 
};
 
typedef enum system_action system_action_t;
 
 
static char const *const log_filename = RL_DAEMON_LOG_FILE;
 
volatile bool daemon_shutdown = false;
 
volatile system_action_t system_action = SYSTEM_ACTION_NONE;
 
gpio_t *gpio_power = NULL;
 
gpio_t *gpio_button = NULL;
 
int adc_calibrate(uint64_t duration) {
    if (duration == 0) {
        errno = EINVAL;
        return -1;
    }
 
    // configure run with minimal data output
    static rl_config_t rl_config_calibration;
    rl_config_reset(&rl_config_calibration);
    rl_config_calibration.background_enable = false;
    rl_config_calibration.interactive_enable = false;
    rl_config_calibration.web_enable = false;
    rl_config_calibration.file_enable = false;
    rl_config_calibration.sample_rate = RL_SAMPLE_RATE_MIN;
    rl_config_calibration.sample_limit = RL_SAMPLE_RATE_MIN * duration;
 
    // perform calibration run
    int res = rl_run(&rl_config_calibration);
 
    // reset sampling status counters
    rl_status_t rl_status;
    rl_status_read(&rl_status);
    rl_status.sample_count = 0;
    rl_status.buffer_count = 0;
    rl_status_write(&rl_status);
 
    return res;
}
 
void button_interrupt_handler(int value) {
    static time_t timestamp_down = -1;
    time_t timestamp = time(NULL);
 
    // capture timestamp on button press
    if (value == 0) {
        timestamp_down = timestamp;
    }
    // process button action on button release
    if (value == 1) {
        // get duration and reset timestamp down
        time_t duration = timestamp - timestamp_down;
        timestamp_down = -1;
 
        // skip further processing on invalid timestamp
        if (duration > timestamp) {
            return;
        }
 
        // get RocketLogger status
        rl_status_t status;
        int ret = rl_status_read(&status);
        if (ret < 0) {
            rl_log(RL_LOG_ERROR, "Failed reading status; %d message: %s", errno,
                   strerror(errno));
        }
 
        if (duration >= RL_BUTTON_EXTRA_LONG_PRESS_SEC) {
            rl_log(RL_LOG_INFO,
                   "Registered extra long press, requesting system shutdown.");
            daemon_shutdown = true;
            system_action = SYSTEM_ACTION_POWEROFF;
            if (!status.sampling) {
                return;
            }
        } else if (duration >= RL_BUTTON_VERY_LONG_PRESS_SEC) {
            rl_log(RL_LOG_INFO,
                   "Registered very long press, requesting system reboot.");
            daemon_shutdown = true;
            system_action = SYSTEM_ACTION_REBOOT;
            if (!status.sampling) {
                return;
            }
        } else if (duration >= RL_BUTTON_LONG_PRESS_SEC) {
            rl_log(RL_LOG_INFO,
                   "Registered long press, requesting daemon restart.");
            daemon_shutdown = true;
            system_action = SYSTEM_ACTION_NONE;
            if (!status.sampling) {
                return;
            }
        }
 
        char *cmd[3] = {"rocketlogger", NULL, NULL};
        if (status.sampling) {
            cmd[1] = "stop";
        } else {
            cmd[1] = "start";
        }
 
        // create child process to start RocketLogger
        pid_t pid = fork();
        if (pid < 0) {
            rl_log(RL_LOG_ERROR, "Failed forking process; %d message: %s",
                   errno, strerror(errno));
        }
        if (pid == 0) {
            // in child process, execute RocketLogger
            execvp(cmd[0], cmd);
            rl_log(RL_LOG_ERROR,
                   "Failed executing `rocketlogger %s`; %d message: %s", cmd,
                   errno, strerror(errno));
        } else {
            // in parent process log pid
            rl_log(RL_LOG_INFO, "Started RocketLogger with pid=%d.", pid);
        }
    }
    // interrupt rate control
    sleep(RL_DAEMON_MIN_INTERVAL);
}
 
static void signal_handler(int signal_number) {
    // signal to terminate the daemon (systemd stop)
    if (signal_number == SIGTERM) {
        signal(signal_number, SIG_IGN);
        rl_log(RL_LOG_INFO, "Received SIGTERM, shutting down daemon.");
        daemon_shutdown = true;
    }
}
 
int main(void) {
    int ret = SUCCESS;
 
    // init log module
    rl_log_init(log_filename, RL_LOG_VERBOSE);
 
    // set effective user ID of the process
    ret = setuid(0);
    if (ret < 0) {
        rl_log(RL_LOG_ERROR, "Failed setting effective user ID; %d message: %s",
               errno, strerror(errno));
        exit(EXIT_FAILURE);
    }
 
    rl_log(RL_LOG_VERBOSE, "running with real user ID: %d", getuid());
    rl_log(RL_LOG_VERBOSE, "running with effective user ID: %d", geteuid());
    rl_log(RL_LOG_VERBOSE, "running with real group ID: %d", getgid());
    rl_log(RL_LOG_VERBOSE, "running with effective group ID: %d", getegid());
 
    // initialize GPIO module
    gpio_init();
 
    // hardware initialization
    gpio_t *gpio_power = gpio_setup(GPIO_POWER, GPIO_MODE_OUT, "rocketloggerd");
    if (gpio_power == NULL) {
        rl_log(RL_LOG_ERROR, "Failed configuring power switch; %d message: %s",
               errno, strerror(errno));
        exit(EXIT_FAILURE);
    }
    ret = gpio_set_value(gpio_power, 1);
    if (ret < 0) {
        rl_log(RL_LOG_ERROR, "Failed powering up cape; %d message: %s", errno,
               strerror(errno));
        exit(EXIT_FAILURE);
    }
 
    // wait for converter soft start (> 1 ms)
    usleep(RL_POWERUP_DELAY_US);
 
    gpio_t *gpio_button =
        gpio_setup_interrupt(GPIO_BUTTON, GPIO_INTERRUPT_BOTH, "rocketloggerd");
    if (gpio_button == NULL) {
        rl_log(RL_LOG_ERROR, "Failed configuring button; %d message: %s", errno,
               strerror(errno));
        exit(EXIT_FAILURE);
    }
 
    // create shared memory for state
    ret = rl_status_shm_init();
    if (ret < 0) {
        rl_log(RL_LOG_ERROR, "Failed initializing status shared memory.");
        exit(EXIT_FAILURE);
    }
 
    // register signal handler for SIGTERM (for stopping daemon)
    struct sigaction signal_action;
    signal_action.sa_handler = signal_handler;
    sigemptyset(&signal_action.sa_mask);
    signal_action.sa_flags = 0;
 
    ret = sigaction(SIGTERM, &signal_action, NULL);
    if (ret < 0) {
        rl_log(RL_LOG_ERROR,
               "can't register signal handler for SIGTERM; %d message: %s",
               errno, strerror(errno));
        exit(EXIT_FAILURE);
    }
 
    // calibrate ADC reference voltage
    rl_log(RL_LOG_INFO, "Performing ADC reference calibration.");
    adc_calibrate(RL_CALIBRATION_DURATION_SEC);
 
    // check error status
    rl_status_t status;
    rl_status_read(&status);
    if (status.error) {
        rl_log(RL_LOG_ERROR, "ADC reference calibration failed, terminating.");
    } else {
        // daemon main loop
        rl_log(RL_LOG_INFO, "RocketLogger daemon running.");
 
        daemon_shutdown = false;
        while (!daemon_shutdown) {
            // wait for interrupt with infinite timeout
            int value = gpio_wait_interrupt(gpio_button, NULL);
            button_interrupt_handler(value);
        }
 
        rl_log(RL_LOG_INFO, "RocketLogger daemon stopped.");
    }
 
    rl_status_read(&status);
 
    // remove shared memory for state
    rl_status_shm_deinit();
 
    // deinitialize and shutdown hardware
    gpio_set_value(gpio_power, 0);
    gpio_release(gpio_power);
    gpio_release(gpio_button);
    gpio_deinit();
 
    // perform requested system action
    if (system_action == SYSTEM_ACTION_REBOOT) {
        rl_log(RL_LOG_INFO, "Rebooting system.");
        sync();
        reboot(RB_AUTOBOOT);
    } else if (system_action == SYSTEM_ACTION_POWEROFF) {
        rl_log(RL_LOG_INFO, "Powering off system.");
        sync();
        reboot(RB_POWER_OFF);
    }
 
    if (status.error) {
        exit(EXIT_FAILURE);
    }
    exit(EXIT_SUCCESS);
}