/*******************************************************************************
*                (c) Freescale Inc. 2004  all rights reserved.                 *
*                                                                              *
*                                                                              *
*     An example application for AN2767 based on MC68HC908QY4, slave node.     *
*     ====================================================================     *
*                                                                              *
*    $File Name     : main.c$                                                  *
*    $Author        : re004c$                                                  *
*    $Date          : Nov-8-2004$                                             *
*    $Version       : 1.1.7.0$                                                 *
*    Function:                                                                 *
*                                                                              *
* ============================================================================ *
* THIS SOFTWARE IS PROVIDED BY FREESCALE SEMICONDUCTOR "AS IS" AND ANY         *
* EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED  *
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE       *
* DISCLAIMED.  IN NO EVENT SHALL FREESCALE SEMICONDUCTOR OR ITS CONTRIBUTORS   *
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR       *
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF         *
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS     *
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN      *
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)      *
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE   *
* POSSIBILITY OF SUCH DAMAGE.                                                  *
*******************************************************************************/

#include <lin.h>
#include "target.h"
#include "board.h"

#define DEBOUNCE 1                                   /* 20.5ms x (1+1) = 41ms */
#define LOW_POWER 195                                /* 20.5ms x (195+1) = 4s */

unsigned char data = 1;
unsigned char id = 0;
unsigned char key_last;
unsigned char count;  
int keycount, low_power_delay;

#define EVER (;;)                                 /* To avoid warning message */

l_u8 LD_SERIAL[] = {0x01, 0x02, 0x03, 0x04};       /* Mandatory serial number */

/*******************************************************************************
*                                                                              *
*    Function name: NodeFailure                                                *
*    Function:      Do the processing necessary to re-start or enter           *
*                   limp-home mode. In this example we enter an endless loop.  *
*                                                                              *
*******************************************************************************/

void NodeFailure (void)
{
    for EVER                                      /* To avoid warning message */
    {
        /* forever */
    }
}


/*******************************************************************************
*                                                                              *
*    Function name: Check                                                      *
*    Function:      Check that the call return_value is success, or enter      *
*                   failure mode.                                              *
*                                                                              *
*******************************************************************************/

void Check (l_bool return_value)
{
    if (return_value)
    {
        NodeFailure();
    }
}


/*******************************************************************************
*                                                                              *
*    Function name: ReadButton                                                 *
*    Function:      The port line is read and its level compared with what     *
*                   it was the previous time through the loop. If it is the    *
*                   same, the counter "keycount" is used for debounce (80ms)   *
*                   If the switch status changes the counter is reset.         *
*                                                                              *
*******************************************************************************/

void ReadButton (void)
{
    unsigned char key;

    key = BUTTON_PIN;                            /* read button on button pin */
    if (key == key_last)                               /* same as last time ? */
    {
        if (keycount == DEBOUNCE)                  /* yes, (debounce + 2)th ? */
        {
            if (key == 0)                                /* yes, key pressed ?*/
            {
                data++;                                     /* increment data */
                if (data == 16) data = 1;            /* wrapping from 15 to 1 */
            }
            keycount ++;                                 /* prevents re-entry */
        }        
        else
        {
            keycount ++;
        }
    }
    else
    {   
        keycount = 0;                              /* no, different, so reset */
        key_last = key;                              /* count and save status */
    }
}


/*******************************************************************************
*                                                                              *
*    Function name: LedDisplay                                                 *
*    Function:      According to mode the LEDs display the 4-bit data field    *
*                                                                              *
*******************************************************************************/ 

void LedDisplay (void)
{
    unsigned char led;
 
    led = data << LED_OFFSET;                         /* drive LEDs with data */

    if (led & 0x08) LED_PORT |= 0x08; else LED_PORT &= ~(0x08);
    if (led & 0x10) LED_PORT |= 0x10; else LED_PORT &= ~(0x10);
    if (led & 0x20) LED_PORT |= 0x20; else LED_PORT &= ~(0x20);
    if (led & 0x40) LED_PORT |= 0x40; else LED_PORT &= ~(0x40);
}        


/*******************************************************************************
*                                                                              *
*    Function name: LinResponse                                                *
*    Function:      According to ID, the response field is sent using "data".  *
*                                                                              *
*******************************************************************************/

void LinResponse (void)
{                  
    l_u8_wr_data_18(data);                                    /* LIN response */
}


/*******************************************************************************
*                                                                              *
*    Function name: CheckLowPower                                              *
*    Function:      Check if the goto_sleep commnad has been received or there *
*                   is no activity on LIN bus for 4 sec.                       *
*                                                                              *
*******************************************************************************/

void CheckLowPower(void)
{
    l_u16 status;
    
    status = l_ifc_read_status_i1();
                                                   /* Sleep command received? */
    if ((status & 0x0008)== L_SLEEP_REQUEST)
    {
        LIN_EN_PIN = 0;      /* disable MC33399 LIN interface turn off LT1121 */
                             /* to reache low power consumption */
    }
                                          
    if ((status & 0x00FF) == 0x00)                     /* No activity on LIN? */
    {
        low_power_delay--;                      /* yes, decrement the counter */
    }
    else
    {
        low_power_delay = LOW_POWER;
    }
    if (low_power_delay == 0)            /* no activity on LIN for 4 seconds? */
    {
        LIN_EN_PIN = 0;        /* yes, disable MC33399 LIN interface turn off */
                               /* LT1121 to reache low power consumption */
    }
}


/*******************************************************************************
*                                                                              *
*    Function name: main                                                       *
*    Function:      Initialize the network and start processing signals in a   *
*                   forever running loop.                                      *
*                                                                              *
 ******************************************************************************/

void main (void)
{
    l_u8   button_request_id = 0;
    l_bool result;
    
    low_power_delay = LOW_POWER;          /* initialize the low power counter */     
    BUTTON_DDR = 0;                            /* set the button pin as input */
    
    LED_DDR |= LED_MASK;                            /* set LED port as output */
    LED_PORT &= ~LED_MASK;                                /* turn the LED off */
  
    LIN_EN_DDR = 1;                           /* set LIN enable pin as output */
    LIN_EN_PIN = 1;                             /* enable 33399 LIN interface */
    
    init_target();
    result = l_sys_init();
    Check(result);
    l_ifc_init_i1();
    ENABLE_INTS();  	                                /* turn on interrupts */
    result = l_ifc_connect_i1();
    Check(result);
    
    TSC = 0x00;                                         /* timer prescaler /1 */
    TSC &= ~(0x20);                                            /* start timer */
    
    l_u8_wr_SlaveRespB0_demo_net(0x81);             /* set the slave response */    

    for EVER
    {
        PET_WATCHDOG();
        
        if (l_flg_tst_res_done())        /* conflict resolving done flag set? */
        {
                                             /* yes, clear the slave response */
            l_u8_wr_SlaveRespB0_demo_net(0x80);  
            l_flg_clr_res_done();                           /* clear the flag */
        }
        
        if (TSC & 0x80)                              /* is overflow flag set? */
        {
            TSC &= ~(0x80);                                  /* yes, clear it */
            count++;                                 /* used for LED flashing */
            ReadButton();                       /* read button on button port */
            LedDisplay();                          /* update LEDs on LED port */
            LinResponse();                            /* provide LIN response */
            CheckLowPower();                      /* check the low power mode */            
        }
    }
}