UserInterfaceMenuNormal.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
#include <stdbool.h>        // typedef bool, true, false

/* -- Special Includes e.g. Onboard or direct attached Equipment ------------ */
//TODO: cleanup of imports, add comments what is imported
#include "ClockKernel.h" // clock kernel
#include "lcd.h"
#include "PushButton.h" // push buttons
//#include "uart.h" // logging
#include "UserInterfaceLcdNormal.h"
#include "UserInterfaceMenu.h" // menuFastFwd_t
#include "UserInterfaceMenuNormal.h"

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

typedef enum
{
    START = 0,     
    CURRENT = 1,   
    TARGET = 2     
} tTimes;

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

// for comment see below
static void UserInterfaceNormalQuickTo(menuFastFwd_t ucbut);

// for comment see below
static void UserInterfaceMenueNormalTime(tTimes which);

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

void UserInterfaceMenueNormalClock(void)
{
    menuNormalClock_t ucbut1 = MENU_NORMAL_START;
    uint8_t utimef = 0;
    bool endTimeReached = false;

    for(;;)
    {
        UserInterfaceLcdNormalClock(ucbut1);
        // no MENU_NORMAL_STOP in following selection because clock is stopped
        ucbut1 = (menuNormalClock_t) PushButtonGetUpDownValue(ucbut1,
                                                              MENU_NORMAL_START,
                                                              MENU_NORMAL_BACK);

        // single shot enter
        if (PushButtonSingleShotEnter())
        {
            if (ucbut1 == MENU_NORMAL_START)
            {
                ClockSetStatus(ClockIsRunning()); // Uhrstart!!
                for(;;)
                {
                    UserInterfaceLcdNormalClock(MENU_NORMAL_STOP);
                    // reached end time??
                    fclock_t clock = ClockGetTime();
                    if ((clock.hour == ClockReadEndTimeHour())
                        && (clock.minute == ClockReadEndTimeMinute()))
                    {
                        ClockSetStatus(0); // Uhrstop!!
                        endTimeReached = true;
                        break;
                    }
                    // single shot enter
                    if (PushButtonSingleShotEnter())
                    {
                        ClockSetStatus(0); // Uhrstop!!
                        break;
                    }
                    // single shot button up
                    if (PushButtonSingleShotUp())
                    {
                        utimef = ClockReadTimeFactor();
                        utimef++;
                        ClockSetTimeFactor(utimef);
                    }
                    // single shot button down
                    if (PushButtonSingleShotDown())
                    {
                        utimef = ClockReadTimeFactor();
                        utimef--;
                        ClockSetTimeFactor(utimef);
                    }
                }
            }
            else //(ucbut1 == MENU_NORMAL_BACK)
            {
                return;
            }
        }
        if (endTimeReached)
        {
            // call menu for quick running to start time
            UserInterfaceMenueNormalQuick();
            endTimeReached = false;
        }
        // single shot back
        if (PushButtonSingleShotBack())
        {
            return;
        }
    }
}

void UserInterfaceMenueNormalQuick(void)
{
    menuFastFwd_t ucbut1 = MENU_FASTFWD_START;  // start time, 00:00, back
    uint16_t uiperiod;

    lcd_clear();
    for(;;)
    {
        UserInterfaceLcdNormalQuick(ucbut1);
        ucbut1 = (menuFastFwd_t) PushButtonGetUpDownValue(ucbut1,
                                                          MENU_FASTFWD_START,
                                                          MENU_FASTFWD_BACK);

        // single shot enter
        if (PushButtonSingleShotEnter())
        {
            // Quick forward to start time or 00:00
            if ((ucbut1 == MENU_FASTFWD_START) || (ucbut1 == MENU_FASTFWD_NULL))
            {
                uiperiod = ClockReadPeriod();
                ClockSetPeriod(10); // change polarity each second
                UserInterfaceNormalQuickTo(ucbut1);
                ClockSetPeriod(uiperiod);
            }
            else // ucbut1 >=2 exit
            {
                return;
            }

        }
        // single shot back "emergency exit"
        if (PushButtonSingleShotBack())
        {
            return;
        }
    }
}

void UserInterfaceMenueNormalTimeFactor(void)
{
    uint8_t ucbut1 = 0;

    ucbut1 = ClockReadTimeFactor();
    for(;;)
    {
        UserInterfaceLcdNormalTimeFactor(ucbut1);
        ucbut1 = PushButtonGetUpDownValue(ucbut1, CLOCK_TIME_FACTOR_MIN,
                                                  CLOCK_TIME_FACTOR_MAX);

        // single shot enter
        if (PushButtonSingleShotEnter())
        {
            ClockSetTimeFactor(ucbut1);
            return;
        }
        // single shot back
        if (PushButtonSingleShotBack())
        {
            return;
        }
    }
}

void UserInterfaceMenueNormalStartTime(void)
{
    UserInterfaceMenueNormalTime(START);
    return;
}

void UserInterfaceMenueNormalCurrentTime(void)
{
    UserInterfaceMenueNormalTime(CURRENT);
    return;
}

void UserInterfaceMenueNormalTargetTime(void)
{
    UserInterfaceMenueNormalTime(TARGET);
    return;
}

/* -- private functions ----------------------------------------------------- */

static void UserInterfaceNormalQuickTo(menuFastFwd_t ucbut)
{
    menuNormalClock_t ucbut2 = MENU_NORMAL_START;
    uint8_t ucminute;
    uint8_t uchour;

    if (ucbut == MENU_FASTFWD_START)
    {
        ucminute = ClockReadStartTimeMinute();
        uchour = ClockReadStartTimeHour();
    }
    else //(ucbut == MENU_FASTFWD_NULL)
    {
        ucminute = 0;
        uchour = 0;
    }

    for(;;) //just as normal clock operation start/stop/back
    {
        UserInterfaceLcdNormalQuickClock(ucbut, ucbut2, ucminute, uchour);
        // no MENU_NORMAL_STOP in following selection because clock is stopped
        ucbut2 = (menuNormalClock_t) PushButtonGetUpDownValue(ucbut2,
                                                              MENU_NORMAL_START,
                                                              MENU_NORMAL_BACK);
        // single shot enter
        if (PushButtonSingleShotEnter())
        {
            if (ucbut2 == MENU_NORMAL_START)
            {
                ClockSetStatus(ClockIsRunning()); // Uhrstart!!
                for(;;)
                {
                    UserInterfaceLcdNormalQuickClock(ucbut, MENU_NORMAL_STOP,
                                                     ucminute, uchour);
                    // reached time??
                    fclock_t clock = ClockGetTime();
                    if ((clock.hour == uchour) && (clock.minute == ucminute))
                    {
                        ClockSetStatus(0); // Uhrstop!!
                        break;
                    }
                    // single shot enter (stop)
                    if (PushButtonSingleShotEnter())
                    {
                        ClockSetStatus(0); // Uhrstop!!
                        break;
                    }
                }
            }
            else //(ucbut2 == MENU_NORMAL_BACK)
            {
                return;
            }
        }
        // single shot back
        if (PushButtonSingleShotBack())
        {
            return;
        }
    }
}

static void UserInterfaceMenueNormalTime(tTimes which)
{
    menuSetTime_t ucbut1 = 1;  // 0=minute, 1=hour, 2=back
    uint8_t ucbut2 = 0;  // time
    uint8_t uctime = 0;
    fclock_t clkTemp = (fclock_t)CLOCK_MIDNIGHT;

    for(;;)
    {
        switch (which)
        {
            case START  : UserInterfaceLcdNormalStartTime(ucbut1); break;
            case CURRENT: UserInterfaceLcdNormalCurrentTime(ucbut1); break;
            case TARGET : UserInterfaceLcdNormalTargetTime(ucbut1); break;
        }
        ucbut1 = (menuSetTime_t) PushButtonGetUpDownValue(ucbut1,
                                                          MENU_SET_MINUTE,
                                                          MENU_SET_BACK);
        // single shot enter
        if (PushButtonSingleShotEnter())
        {
            // Set minute
            if (ucbut1 == MENU_SET_MINUTE)
            {
                switch (which)
                {
                    case START :
                        ucbut2 = ClockReadStartTimeMinute();
                        uctime = ClockReadStartTimeHour();
                        break;
                    case CURRENT :
                        clkTemp = ClockGetTime();
                        ucbut2 = clkTemp.minute;
                        uctime = clkTemp.hour;
                        break;
                    case TARGET :
                        ucbut2 = ClockReadEndTimeMinute();
                        uctime = ClockReadEndTimeHour();
                        break;
                }
                for(;;)
                {
                    switch (which)
                    {
                        case START:
                            UserInterfaceLcdNormalStartTimeSet(ucbut2, uctime);
                            break;
                        case CURRENT:
                            UserInterfaceLcdNormalCurrentTimeSet(ucbut2, uctime);
                            break;
                        case TARGET:
                            UserInterfaceLcdNormalTargetTimeSet(ucbut2, uctime);
                            break;
                    }
                    ucbut2 = PushButtonGetUpDownValue(ucbut2, 0, 59);
                    // single shot enter
                    if (PushButtonSingleShotEnter())
                    {
                        switch (which)
                        {
                            case START:
                                ClockSetStartTimeMinute(ucbut2);
                                break;
                            case CURRENT:
                                clkTemp = ClockGetTime();
                                clkTemp.minute = ucbut2;
                                ClockSetTime(clkTemp);
                                break;
                            case TARGET:
                                ClockSetEndTimeMinute(ucbut2);
                                break;
                        }
                        break;
                    }
                    // single shot back
                    if (PushButtonSingleShotBack())
                    {
                        break;
                    }
                }
            }
            // Set hour
            else if (ucbut1 == MENU_SET_HOUR)
            {
                switch (which)
                {
                    case START :
                        uctime = ClockReadStartTimeMinute();
                        ucbut2 = ClockReadStartTimeHour();
                        break;
                    case CURRENT :
                        clkTemp = ClockGetTime();
                        uctime = clkTemp.minute;
                        ucbut2 = clkTemp.hour;
                        break;
                    case TARGET :
                        uctime = ClockReadEndTimeMinute();
                        ucbut2 = ClockReadEndTimeHour();
                        break;
                }
                for(;;)
                {
                    switch (which)
                    {
                        case START:
                            UserInterfaceLcdNormalStartTimeSet(uctime, ucbut2);
                            break;
                        case CURRENT:
                            UserInterfaceLcdNormalCurrentTimeSet(uctime, ucbut2);
                            break;
                        case TARGET:
                            UserInterfaceLcdNormalTargetTimeSet(uctime, ucbut2);
                            break;
                    }
                    ucbut2 = PushButtonGetUpDownValue(ucbut2, 0, 23);
                    // single shot enter
                    if (PushButtonSingleShotEnter())
                    {
                        switch (which)
                        {
                            case START:
                                ClockSetStartTimeHour(ucbut2);
                                break;
                            case CURRENT:
                                clkTemp = ClockGetTime();
                                clkTemp.hour = ucbut2;
                                ClockSetTime(clkTemp);
                                break;
                            case TARGET:
                                ClockSetEndTimeHour(ucbut2);
                                break;
                        }
                        break;
                    }
                    // single shot back
                    if (PushButtonSingleShotBack())
                    {
                        break;
                    }
                }
            }
            else //(ucbut1 == MENU_SET_BACK)
            {
                return;
            }
        }
        // single shot back "emergency exit"
        if (PushButtonSingleShotBack())
        {
            return;
        }
    }
}