/*C**************************************************************************
* NAME:         kbd_task.c
*----------------------------------------------------------------------------
* Copyright (c) 2003 Atmel.
*----------------------------------------------------------------------------
* RELEASE:      snd1c-refd-nf-4_0_3      
* REVISION:     1.3.2.16     
*----------------------------------------------------------------------------
* PURPOSE:
* This file contains the keyboard task and attached routines
*
* NOTES:
* Global Variables:
*   - gl_key_press: bit in bdata space
*   - gl_key:       byte in idata space
*   - gl_kbd_tick:  byte in data space
*****************************************************************************/

/*_____ I N C L U D E S ____________________________________________________*/

#include "config.h"                         /* system configuration */
#include "lib_refd\board.h"                          /* board definition */
#include "lib_mcu\kbd\kbd_drv.h"            /* Keyboard driver definition */
#include "kbd_task.h"                       /* Keyboard task definition */
#include "modules\file\file.h"              /* file definition */
#include "modules\mem\mem_task.h"           /* memory task definition */
//#include "modules\display\led.h"            /* led definition */
#include "modules\mode\mode_task.h"         /* mode task definition */

#define REF_STATE_SONG      0
#define REF_STATE_VOICE     1
#define REF_STATE_USB       2
#define REF_STATE_FORMAT    3


/*_____ M A C R O S ________________________________________________________*/


/*_____ D E F I N I T I O N ________________________________________________*/

extern  bdata   bit     gl_key_press;       /* set to TRUE if a key is decoded */
extern  idata   Byte    gl_key;             /* value of the key pressed */
extern  data    Byte    gl_kbd_tick;        /* keypad tick counter */

extern  idata   Uint16  gl_act_tick;        /* Activity tick */
extern          Byte    song_state;         /* task state */
extern  data    Byte    mode_state;         /* task state */

extern  xdata   Byte    LED_ON;
extern  xdata   Byte    LED_FAST;

xdata   Byte    func_state;
xdata   Byte    func_timeout;               /* Time out special function */
xdata   Byte    ref_state = REF_STATE_SONG;
        bit     playing = FALSE;
        bit     pause = FALSE;
        bit     recording = FALSE;
        bit     connected = FALSE;
        bit     bargraph = FALSE;

static  Byte    kbd_state;                  /* keyboard task state */


/*_____ D E C L A R A T I O N ______________________________________________*/

void usb_task_init (void);


/*F**************************************************************************
* NAME: kbd_task_init
*----------------------------------------------------------------------------
* PARAMS:
*
* return:
*----------------------------------------------------------------------------
* PURPOSE: 
*   Keyboard task initialisation
*----------------------------------------------------------------------------
* EXAMPLE:
*----------------------------------------------------------------------------
* NOTE:
*----------------------------------------------------------------------------
* REQUIREMENTS:
*****************************************************************************/
void kbd_task_init (void)
{
  kbd_state = KBD_IDLE;
  gl_key_press = FALSE;         /* no key pressed */
  gl_key = NO_KEY;
  kbd_init();                   /* keyboard initialization */
}


/*F**************************************************************************
* NAME: ref_mode_task
*----------------------------------------------------------------------------
* PARAMS:
*
* return:
*----------------------------------------------------------------------------
* PURPOSE: 
*   Mode task 
*----------------------------------------------------------------------------
* EXAMPLE:
*----------------------------------------------------------------------------
* NOTE:
*   STATES:
*   MODE_BOOT     boot state
*   MODE_DOWNLOAD file download mode
*   MODE_SONG     song playing mode
*   MODE_VOICE    voice playing & recording mode
*   MODE_TOOL     tool mode
*   MODE_IDLE     idle mode (switch back to first task)
*----------------------------------------------------------------------------
* REQUIREMENTS:
*****************************************************************************/
void ref_mode_task (void)
{
  gl_key_press = FALSE;
  func_timeout = 0;
  gl_act_tick = 0;
  if (connected)
  {
    if (gl_key != KEY_FUNC) return;
    connected = FALSE;
    mode_state = MODE_SONG;
    ENA_USB = !connected;
    goto Label_init_ihm;
  }
  else if (gl_key == KEY_PLUS)
  {
    gl_key_press = TRUE;
    if (func_state) { gl_key = KEY_INC; bargraph=TRUE; }
    else gl_key = KEY_NEXT;
  }
  else if (gl_key == KEY_MINUS)
  {
    gl_key_press = TRUE;
    if (func_state) { gl_key = KEY_DEC; bargraph=TRUE; }
    else gl_key = KEY_PREV;
  }
  else if (recording)
  {
    if      (gl_key == KEY_FUNC)
    {
      gl_key_press = TRUE;
      if (playing) gl_key = KEY_PAUSE;
      else         gl_key = KEY_REC;
      SHUT_MIC = playing;
    }
    else if (gl_key == KEY_VALID)
    {
      if (pause || playing)
      {
        gl_key_press = TRUE;
        gl_key = KEY_STOP;
      }
      else recording=FALSE;
      LED_ON = (8 >> ref_state);
      LED_FAST = 3;
    }
  }
  else if (playing)
  {
    bargraph=FALSE;
    if      (gl_key == KEY_FUNC)
    {
      gl_key_press = TRUE;
      if ((func_state == 2) && (ref_state == REF_STATE_VOICE)) gl_key = KEY_STOP;
      else gl_key = KEY_PAUSE;
    }
    else if (gl_key == KEY_VALID)
    {
      if (ref_state == REF_STATE_VOICE)
      {
        if (func_state == 1) { func_state=2; LED_ON = 4; }
        else                 { func_state=1; LED_ON = 8; }
        LED_FAST = 2;
      }
      else
      {
        if (func_state)
        {
          gl_key_press = TRUE;
          gl_key = KEY_SOUND;
        }
        if (func_state>=5) func_state = 0;
        func_state++;
        LED_FAST = 2;
        if (func_state == 5)
        {
          LED_ON=7;
          if (MP3CON & MSK_MPBBST) LED_FAST = 1;
        }
        else LED_ON = (16>>func_state);
      }
    }
  }
  else
  {
    if      (gl_key == KEY_FUNC)
    {
      func_state=0;
      if (ref_state == REF_STATE_SONG)
      {
        gl_key_press = TRUE;
        gl_key = KEY_PLAY;
        mode_state = MODE_SONG;
      }
      else if (ref_state == REF_STATE_VOICE)
      {
        gl_key_press = TRUE;
        if (func_state == 2) gl_key = KEY_REC;
        else               gl_key = KEY_PLAY;
        mode_state = MODE_VOICE;
      }
      else if (ref_state == REF_STATE_USB)    // && !connected
      {
        usb_task_init ();
        connected = TRUE;
        mode_state = MODE_DOWNLOAD;
        ENA_USB = !connected;
      }
      else if (ref_state == REF_STATE_FORMAT)
      {
        Fformat();
        if (mem_select_format() != OK) LED_FAST=1; /* check file system */
        else LED_FAST = 3;
      }
    }
    else if (gl_key == KEY_VALID)
    {
      if (pause)
      {
        pause = FALSE;
        gl_key_press = TRUE;
        gl_key = KEY_STOP;
      }
      if (ref_state >= 3)
      {
      Label_init_ihm:
        ref_state = 0;
        mode_task_init();
      }
      else ref_state++;
      LED_ON = (8 >> ref_state);
      LED_FAST = 3;
    }
  }
}


/*F**************************************************************************
* NAME: kbd_task
*----------------------------------------------------------------------------
* PARAMS:
*
* return:
*----------------------------------------------------------------------------
* PURPOSE: 
*   Keyboard task
*----------------------------------------------------------------------------
* EXAMPLE:
*----------------------------------------------------------------------------
* NOTE:
*----------------------------------------------------------------------------
* REQUIREMENTS:
*****************************************************************************/
void kbd_task (void)
{
  switch (kbd_state)
  {
    case KBD_IDLE:
      if (Kbd_key_pressed())
      {
        gl_kbd_tick = KBD_DEBOUNCE_INIT;  /* init debounce timer */
        kbd_state = KBD_DEBOUNCE;
      }
      break;

    case KBD_DEBOUNCE:
      if (gl_kbd_tick > KBD_DEBOUNCE_TEMPO)
      {
        kbd_state = KBD_DECODE;
      }
      break;

    case KBD_DECODE:
      gl_key = kbd_decode();              /* read key pressed */
      if (gl_key != NO_KEY)               /* if real key pressed */
        gl_key_press = TRUE;              /* signal to other tasks */
      kbd_state = KBD_IDLE;
      break;

    default:
      break;
  }

  // Add driver keyboard for Reference Design:
  // Re-map physical keys over logical demoboard keys
  if (gl_key_press == TRUE && gl_key < NO_KEY) ref_mode_task();
  if (connected && (mode_state == MODE_SONG))
  { /* download exit */
    gl_key_press = TRUE;
    gl_key = KEY_FUNC;
  }
}


/*F**************************************************************************
* NAME: kbd_set_stop
*----------------------------------------------------------------------------
* PARAMS:
*
* return:
*----------------------------------------------------------------------------
* PURPOSE: 
*   Simulate STOP key press
*----------------------------------------------------------------------------
* EXAMPLE:
*----------------------------------------------------------------------------
* NOTE:
*   Called from mode task before switching to download state
*----------------------------------------------------------------------------
* REQUIREMENTS:
*****************************************************************************/
void kbd_set_stop (void)
{
  gl_key = KEY_STOP;
  gl_key_press = TRUE;
  kbd_state = KBD_IDLE;
}