timer_internal.c

Go to the documentation of this file.

////////////////////////////////////////////////////////////////////////////////
//     
//    __                                ______
//   / /_______________  ____  ___     / ____/
//  / __/ ___/ ___/ __ \/ __ \/ _ \   /___ )  
// / /_(__  ) /__/ /_/ / /_/ /  __/  ____/ /  
// \__/____/\___/\____/ .___/\___/  /_____/   
//                   /_/                      
//     
/// \file timer_internal.c
/// Definitions of internal timer functions.
////////////////////////////////////////////////////////////////////////////////

#include "../include/tscope5/timer_internal.h"
#include "../include/tscope5/system_internal.h"

#ifdef TS5_LINUX
    #include <sys/ioctl.h>
    #include <linux/rtc.h>

#endif

/// Is the timer subsystem installed?
int _ts5_is_timer_installed = 0;

/// Is the realtime clock installed
int _ts5_is_realtime_clock_installed = 0;


////////////////////////////////////////////////////////////////////////////////
/// Do some checks at the start of each timer function.
///
/// \param calling_function Name the function that calls 
/// for this check or installation.
///
/// Checks whether the timer is installed. If not, the timer is installed.
////////////////////////////////////////////////////////////////////////////////
void ts5_check_timer(char *calling_function)
{
    ts5_log(TS5_LOGLEVEL_6, "%s: ts5_check_timer\n", calling_function);
    if (!_ts5_is_timer_installed) {
        ts5_install_timer(calling_function);
    }
}


////////////////////////////////////////////////////////////////////////////////
/// Do some checks at the start of each timer function.
///
/// \param calling_function Name the function that calls 
/// for this check or installation.
///
/// Checks whether there are active response buttons. Aborts if necessary.
////////////////////////////////////////////////////////////////////////////////
void ts5_check_timer2(char *calling_function)
{
    ts5_log(TS5_LOGLEVEL_6, "%s: ts5_check_timer2\n", calling_function);
    if (_ts5_status.timer.num_active_buttons<1) {
        ts5_fatal("%s: there are no active response buttons\n", 
            calling_function);
    }
}


////////////////////////////////////////////////////////////////////////////////
/// Do some checks at the start of each timer function.
///
/// \param calling_function Name the function that calls 
/// for this check or installation.
///
/// Checks whether there are active trigger devices. Aborts if necessary.
////////////////////////////////////////////////////////////////////////////////
void ts5_check_timer3(char *calling_function)
{
    ts5_log(TS5_LOGLEVEL_6, "%s: ts5_check_timer3\n", calling_function);
    
    int found=0;

    if (_ts5_status.timer.cedrusbox_is_trigger_device) {

        int i;
        for (i=0; i<_ts5_status.timer.num_cedrusboxes; i++) {

            if (_ts5_status.timer.cedrusbox[i].is_trigger_input_device) {
                found=1;
            }
        }
    }

    if (_ts5_status.timer.parport_is_trigger_device) {

        int i;
        for (i=0; i<_ts5_status.timer.num_parports; i++) {

            if (_ts5_status.timer.parport[i].is_trigger_input_device) {
                found=1;
            }
        }
    }

    if (_ts5_status.timer.serialport_is_trigger_device) {

        int i;
        for (i=0; i<_ts5_status.timer.num_serialports; i++) {

            if (_ts5_status.timer.serialport[i].is_trigger_input_device) {
                found=1;
            }
        }
    }

    if (!found) {
        ts5_fatal("%s: there are no trigger input devices\n", calling_function);
    }
}


////////////////////////////////////////////////////////////////////////////////
/// Do some checks at the start of each timer function.
///
/// \param calling_function Name the function that calls 
/// for this check or installation.
///
/// Checks whether the realtime clock is installed. 
/// If not, the realtime clock is installed.
////////////////////////////////////////////////////////////////////////////////
void ts5_check_timer4(char *calling_function)
{
    ts5_log(TS5_LOGLEVEL_6, "%s: ts5_check_timer4\n", calling_function);

    if (!_ts5_is_timer_installed) {
        ts5_install_realtime_clock(calling_function);
    }
}


////////////////////////////////////////////////////////////////////////////////
/// Install the timer subsystem.
///
/// \param calling_function Name the function that calls 
/// for this check or installation.
///
/// This function is called automatically if necessary.
////////////////////////////////////////////////////////////////////////////////
void ts5_install_timer(char *calling_function)
{
    if (!_ts5_is_tscope5_installed) {
        ts5_install_tscope5(calling_function);
    }

    if (!_ts5_is_timer_installed) {

        _ts5_is_timer_installed = 1;
        ts5_log(TS5_LOGLEVEL_1, "%s: Installing Tscope5 timer\n", 
            calling_function);

        _ts5_data.timer.response_queue = al_create_event_queue();

        if (_ts5_data.timer.response_queue==NULL) {
            ts5_fatal("%s: could not install timer\n", calling_function);
        }

        _ts5_data.timer.trigger_queue = al_create_event_queue();

        if (_ts5_data.timer.trigger_queue==NULL) {
            ts5_fatal("%s: could not install timer\n", calling_function);
        }

        _ts5_data.timer.trigger_log = al_create_event_queue();

        if (_ts5_data.timer.trigger_log==NULL) {
            ts5_fatal("%s: could not install timer\n", calling_function);
        }

        atexit(ts5_uninstall_timer);
    }
}


////////////////////////////////////////////////////////////////////////////////
/// Uninstall the timer subsystem.
///
/// This function is called automatically at the end of the program.
////////////////////////////////////////////////////////////////////////////////
void ts5_uninstall_timer()
{
    if (_ts5_is_timer_installed) {

        ts5_log(TS5_LOGLEVEL_1, "Uninstalling Tscope5 timer\n");

        al_flush_event_queue(_ts5_data.timer.response_queue);
        al_flush_event_queue(_ts5_data.timer.trigger_queue);
        al_flush_event_queue(_ts5_data.timer.trigger_log);

        al_destroy_event_queue(_ts5_data.timer.response_queue);
        al_destroy_event_queue(_ts5_data.timer.trigger_queue);
        al_destroy_event_queue(_ts5_data.timer.trigger_log);

        _ts5_is_timer_installed = 0;
    }
}


////////////////////////////////////////////////////////////////////////////////
/// Install the realtime clock.
///
/// \param calling_function Name the function that calls 
/// for this check or installation.
///
/// This function is called automatically if necessary.
////////////////////////////////////////////////////////////////////////////////
void ts5_install_realtime_clock(char *calling_function)
{
    if (!_ts5_is_tscope5_installed) {
        ts5_install_tscope5(calling_function);
    }

    if (!_ts5_is_timer_installed) {
        ts5_install_timer(calling_function);
    }
    
    if (!_ts5_is_realtime_clock_installed) {

        _ts5_is_realtime_clock_installed = 1;
        ts5_log(TS5_LOGLEVEL_1, "%s: Installing Tscope5 realtime clock\n", 
            calling_function);

        #ifdef TS5_LINUX
            if (geteuid() != 0) {
                ts5_fatal("%s: %s\n", "ts5_install_realtime_clock",
                    "only root can open the realtime clock");
            }


            if ((_ts5_data.timer.realtime_clock 
                    = open("/dev/rtc", O_RDONLY)) < 0) {
                ts5_fatal("%s: %s\n", "ts5_install_realtime_clock", 
                    "error opening realtime clock");
            }

            if (ioctl(_ts5_data.timer.realtime_clock, RTC_IRQP_SET, 8192) < 0) {
                ts5_fatal("%s: %s\n", "ts5_install_realtime_clock", 
                    "error setting realtime clock frequency");
            }       
            
            if (ioctl(_ts5_data.timer.realtime_clock, RTC_PIE_ON, 0) < 0) {
                ts5_fatal("%s: %s\n", "ts5_install_realtime_clock", 
                    "error setting realtime clock interrupts");
            }

            atexit(ts5_uninstall_realtime_clock);
        
        #endif

    }
}


////////////////////////////////////////////////////////////////////////////////
/// Uninstall the realtime clock.
///
/// This function is called automatically at the end of the program.
////////////////////////////////////////////////////////////////////////////////
void ts5_uninstall_realtime_clock()
{
    if (_ts5_is_realtime_clock_installed) {

        ts5_log(TS5_LOGLEVEL_1, "Uninstalling Tscope5 realtime clock\n");

        #ifdef TS5_LINUX
            if (ioctl(_ts5_data.timer.realtime_clock, RTC_PIE_OFF, 0) < 0) {
                ts5_fatal("%s: %s\n", "ts5_uninstall_realtime_clock", 
                    "error removing realtime clock interrupts");
            }

            close(_ts5_data.timer.realtime_clock);
        
        #endif
                 
        _ts5_is_realtime_clock_installed = 0;
    }
}


////////////////////////////////////////////////////////////////////////////////
/// Give up processor time to allow other processes to run.
////////////////////////////////////////////////////////////////////////////////
void ts5_realtime_clock_nap()
{
    #ifdef TS5_WINDOWS
        Sleep(0);
    
    #elif defined TS5_LINUX
        if (_ts5_is_realtime_clock_installed) {
            unsigned long timedata;
            if (read(_ts5_data.timer.realtime_clock, &timedata, 
                    sizeof(unsigned long)) < 0) {
                ts5_fatal("%s: %s\n", "ts5_realtime_clock_nap",
                    "error reading realtime clock");
            }
        }
    
    #endif
    
}