ClockKernel.c

Go to the documentation of this file.

/*
    Copyright (C) 2007 Bernd Wisotzki

    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Lesser General Public
    License as published by the Free Software Foundation; either
    version 2.1 of the License, or (at your option) any later version.

    This library 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
    Lesser General Public License for more details.

    You should have received a copy of the GNU Lesser General Public
    License along with this library; if not, write to the Free Software
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
*/

/* -- System wide includes -------------------------------------------------- */
#include <stdint.h>         // typedef uint8_t, typedef uint16_t
#include <stdbool.h>        // typedef bool, true, false
#include <util/atomic.h>    // #define ATOMIC_BLOCK(), ATOMIC_RESTORESTATE

/* -- Special Includes e.g. Onboard or direct attached Equipment ------------ */
//TODO: cleanup of imports, add comments what is imported
#include "sysdef.h"
#include "ClockKernel.h"

/* -- global Variables ------------------------------------------------------ */

//const fclock_t CLOCK_MIDNIGHT = { 0, 0 };

/* -- Variables for clock kernel -------------------------------------------- */

/* -- Variables shared between user interface and interrupt routine ----- */
static volatile uint16_t uiClockTimer  = 0;

static volatile uint16_t uiClockPeriod = 0;

static volatile uint16_t uiClockPulse  = 0;

static volatile uint8_t  ucClockStatus = 0;

static volatile bool     ucClockOddPulse = 0;

static volatile fclock_t ucClock = CLOCK_MIDNIGHT;

/* -- Variables used only by user interface ----------------------------- */
static uint8_t ucClockTimeFactor;
static uint8_t ucStartTimeMinute;
static uint8_t ucStartTimeHour;
static uint8_t ucEndTimeMinute;
static uint8_t ucEndTimeHour;

/* -- Function prototypes internal functions -------------------------------- */

// for comment see below
static void ClockGeneratePulse(void);

/* -- Standard functions ---------------------------------------------------- */

void ClockKernelInit(void)
{
    // Initialize the port for pulse generation

    #if defined BOARD_PROTO_128 //ProtoBoardMega128
        //---- Port G: mega128 only. For developement purposes
        // Used for pulse generation and push button status
        //PORTG = 0xee; // PG0-4 outputs -> driven low (LEDs)
        CLOCK_PORT = 0x1F; //  All LED off
        //PORTG &=~_BV(PG0); //Bit clear
        //PORTG |=_BV(PG0); //Bit set
        PORTG &= ~_BV(PG3);
        PORTG &= ~_BV(PG4);
        CLOCK_DDR  = 0x1f;  //
    #elif defined BOARD_PROTO_48 //ProtoBoardMega48
        CLOCK_PORT &= (~_BV(CLOCK_PULSE_ENABLE12) & ~_BV(CLOCK_PULSE_ENABLE34)
                       & ~_BV(CLOCK_PULSE_ODD) & ~_BV(CLOCK_PULSE_EVEN)); //  All pulse related bits off
        CLOCK_DDR |= (_BV(CLOCK_PULSE_ENABLE12) | _BV(CLOCK_PULSE_ENABLE34)
                      | _BV(CLOCK_PULSE_ODD) | _BV(CLOCK_PULSE_EVEN)); //  All pulse related output
        CLOCK_PORT |= (_BV(CLOCK_PULSE_ENABLE12) | _BV(CLOCK_PULSE_ENABLE34)); //  Enable both clocl lines
    #endif //Boardtype
}

void SysTimerUserInterrupt(void)
{
    // add your functioncalls and code as apropriate
}

void SysTimerUserInterrupt10(void)
{
    // add your functioncalls and code as apropriate
}

void SysTimerUserInterrupt100(void)
{
    // add your functioncalls and code as apropriate    
    ClockGeneratePulse();
}

/* -- User specific functions ----------------------------------------------- */

/* -- Functions for Clock --------------------------------------------------- */

/* Initalize clock */
/*void ClockInit(void)
{
    // Wat machen mer denn da???
    // Na logisch, einlesen der Werte ausm EEPROM, doofe Frage!
}*/

void ClockSetStatus(uint8_t ucStatus)
{
    ATOMIC_BLOCK(ATOMIC_RESTORESTATE) // save SREG, cli() and restore SREG
    {
        ucClockStatus = ucStatus;
        if (ucStatus >= _BV(CLOCK_STATUS_RUN))
        {
            uiClockTimer = uiClockPeriod;
        }
        if (ucStatus >= (_BV(CLOCK_STATUS_RUN) | _BV(CLOCK_STATUS_TIME)))
        {
            // Uups, we have to calculate odd/even from the actual time!!
            ucClockOddPulse = (bool) (ucClock.minute & _BV(0)); // true=1, false=0
        }
    }
}

#pragma GCC diagnostic push // avoid false positive on gcc 4.9.2
#pragma GCC diagnostic ignored "-Wreturn-type"
uint8_t ClockReadStatus(void) //TODO: never used
{
    ATOMIC_BLOCK(ATOMIC_RESTORESTATE)
    {
        return ucClockStatus;
    }
}
#pragma GCC diagnostic pop

uint8_t ClockIsRunning(void) //FIXME: this is a function used as const value
{
    return (_BV(CLOCK_STATUS_RUN) | _BV(CLOCK_STATUS_TIME));
}

void ClockSetPeriod(uint16_t uiPeriod)
{
    ATOMIC_BLOCK(ATOMIC_RESTORESTATE)
    {
        uiClockPeriod = uiPeriod;
    }
}

#pragma GCC diagnostic push // avoid false positive on gcc 4.9.2
#pragma GCC diagnostic ignored "-Wreturn-type"
uint16_t ClockReadPeriod(void)
{
    ATOMIC_BLOCK(ATOMIC_RESTORESTATE)
    {
        return uiClockPeriod;
    }
}
#pragma GCC diagnostic pop

void ClockSetPulse(uint16_t uiPulse)
{
    ATOMIC_BLOCK(ATOMIC_RESTORESTATE)
    {
        uiClockPulse = uiPulse;
    }
}

#pragma GCC diagnostic push // avoid false positive on gcc 4.9.2
#pragma GCC diagnostic ignored "-Wreturn-type"
uint16_t ClockReadPulse(void)
{
    ATOMIC_BLOCK(ATOMIC_RESTORESTATE)
    {
        return uiClockPulse;
    }
}
#pragma GCC diagnostic pop

void ClockSetTime(fclock_t newValue)
{
    ATOMIC_BLOCK(ATOMIC_RESTORESTATE)
    {
        ucClock = newValue;
    }
}

#pragma GCC diagnostic push // avoid false positive on gcc 4.9.2
#pragma GCC diagnostic ignored "-Wreturn-type"
fclock_t ClockGetTime(void)
{
    ATOMIC_BLOCK(ATOMIC_RESTORESTATE)
    {
        return ucClock;
    }
}
#pragma GCC diagnostic pop

void ClockSetTimeFactor(uint8_t ucFactor)
{
    if (ucFactor < CLOCK_TIME_FACTOR_MIN)
    {
        ucFactor = CLOCK_TIME_FACTOR_MIN;
    }
    else if (ucFactor > CLOCK_TIME_FACTOR_MAX) 
    {
        ucFactor = CLOCK_TIME_FACTOR_MAX;
    }
    ucClockTimeFactor = ucFactor;
    ClockSetPeriod(CLOCK_PERIOD_10 / ucClockTimeFactor);
}

uint8_t ClockReadTimeFactor(void)
{
    return ucClockTimeFactor;
}

void ClockSetStartTimeMinute(uint8_t ucMinute)
{
    ucStartTimeMinute = ucMinute;
}

uint8_t ClockReadStartTimeMinute(void)
{
    return ucStartTimeMinute;
}

void ClockSetStartTimeHour(uint8_t ucHour)
{
    ucStartTimeHour = ucHour;
}

uint8_t ClockReadStartTimeHour(void)
{
    return ucStartTimeHour;
}

void ClockSetEndTimeMinute(uint8_t ucMinute)
{
    ucEndTimeMinute = ucMinute;
}

uint8_t ClockReadEndTimeMinute(void)
{
    return ucEndTimeMinute;
}

void ClockSetEndTimeHour(uint8_t ucHour)
{
    ucEndTimeHour = ucHour;
}

uint8_t ClockReadEndTimeHour(void)
{
    return ucEndTimeHour;
}

static void ClockGeneratePulse(void)
{
    if (ucClockStatus >= _BV(CLOCK_STATUS_RUN))
    {
        uiClockTimer--;

        if (uiClockTimer == 0)
        {
            uiClockTimer = uiClockPeriod;
            // pulse off!!
            CLOCK_PORT &= ~_BV(CLOCK_PULSE_ODD);    //Bit clear odd bit
            CLOCK_PORT &= ~_BV(CLOCK_PULSE_EVEN);   //Bit clear even bit
        }

        if (uiClockTimer == uiClockPulse)
        {
            //Set pulse and toggle odd/even
            if (ucClockOddPulse)
            {
                CLOCK_PORT |=_BV(CLOCK_PULSE_ODD);  //Bit set odd bit
                ucClockOddPulse = false;
            }
            else //(!ucClockOddPulse)
            {
                CLOCK_PORT |=_BV(CLOCK_PULSE_EVEN); //Bit set even bit
                ucClockOddPulse = true;
            }

            if (ucClockStatus >= (_BV(CLOCK_STATUS_RUN) | _BV(CLOCK_STATUS_TIME)))
            {
                // increment actual time
                ucClock.minute++;
                if (ucClock.minute >= 60)
                {
                    ucClock.minute = 0;
                    ucClock.hour++;
                }
                if (ucClock.hour >= 24)
                {
                    ucClock.hour = 0;
                }
            }
        } // (uiClockTimer == uiClockPulse)
    }
    else
    {
        if ( ((CLOCK_PORT & _BV(CLOCK_PULSE_ODD)) != 0)
             || ((CLOCK_PORT & _BV(CLOCK_PULSE_EVEN)) != 0) ) //pulse active?
        {
            uiClockTimer--;
            if (uiClockTimer == 0)
            {
                uiClockTimer = uiClockPeriod;
                // pulse off!!
                CLOCK_PORT &= ~_BV(CLOCK_PULSE_ODD);    //Bit clear odd bit
                CLOCK_PORT &= ~_BV(CLOCK_PULSE_EVEN);   //Bit clear even bit
            }
        }
    }
}