appl.c

Go to the documentation of this file.

// ////////////////////////////////////////////////////////////////////////////
// ////////////////////////////////////////////////////////////////////////////
    #define     APPL_C


// ////////////////////////////////////////////////////////////////////////////
// Includes
// ////////////////////////////////////////////////////////////////////////////

    #include    "appl.h"
    #include    "mdns.h"
    #include    "TCPIP.h"
    #include    "stringtable.h"

    #include    "projectdefs.h"


// ////////////////////////////////////////////////////////////////////////////
// Local Defines
// ////////////////////////////////////////////////////////////////////////////


// ////////////////////////////////////////////////////////////////////////////
// Local Typedefs
// ////////////////////////////////////////////////////////////////////////////

// States of application
typedef enum
{
    APPL_SM_START = 0,
    APPL_SM_ADD_ERR_ACK,
    APPL_SM_PROCESS_ADD,
    APPL_SM_PREPARE_SRCP,
    APPL_SM_SET_SRCP,
    APPL_SM_PROCESS_SRCP,
    APPL_SM_WAIT_FOR_MDNS_RESOLVE,
    APPL_SM_RESOLVE_MAC,
    APPL_SM_WAIT_FOR_SERVER_REPLY,
    APPL_SM_IDLE_CONNECT,
    APPL_SM_HANDLE_CONNECTION,
    APPL_SM_WAIT_FOR_USER,
    APPL_SM_CONNECTED,
    APPL_SM_CONNECTION_CLOSED,
    APPL_SM_START_SHUTDOWN,
    APPL_SM_SHUTDOWN,
    APPL_SM_SERVERSET,
    APPL_SM_ERROR_CONNECT
} SM_APPL;

typedef struct __attribute__((__packed__)) _servernet_config 
{
    NODE_INFO   sSrvAdd;
    WORD_VAL    sPort;
} SSERVERNET;


// ////////////////////////////////////////////////////////////////////////////
// Local variables
// ////////////////////////////////////////////////////////////////////////////

static SM_APPL _eApplSM;
static BYTE _u8retry_counter;
static SSERVERNET _sServerConfig;


// ////////////////////////////////////////////////////////////////////////////
// Local function prototypes
// ////////////////////////////////////////////////////////////////////////////

static BOOL disconnect(void);


// ////////////////////////////////////////////////////////////////////////////
// ////////////////////////////////////////////////////////////////////////////

void ApplInit(void)
{
    _eApplSM = APPL_SM_START;
    u8ApplTimer = 0;

    BootupInit();

    // Network-Application data from external EEPROM
    {
        BYTE * confPtr = (BYTE *)(&sPApplConfig);
        XEEReadArray(APPL_EEPROM_ADD, confPtr, sizeof(SPAPPLDATA));
    }

    // ////////////////////////////////////////////////////////////////////////
    // Init the 10 ms timer:

    // Switch timer3 off
    T3CON = 0;  

    // Init the periode register for a 10 ms duration...
    CCPR2H = (GetPeripheralClock() * 0.005) / 256;
    CCPR2L = (GetPeripheralClock() * 0.005);
    CCP2CON = 0x0B;     // Compare mode, generate software interrupt on match.
    IPR2bits.CCP2IP = 0;    // Low interrupt priority.
    PIR2bits.CCP2IF = 0;    // Interrupt flag zuruecksetzen.
    PIE2bits.CCP2IE = 0;    // Disable the interrupt flag.

    TMR3L = 0;  // Reset the
    TMR3H = 0;  // timer.

    // Timer1 as clock source for CCP1, Timer3 as clock source for CCP2
    T3CONbits.T3CCP1 = 1;

    // Set prescaler to 1:2
    T3CONbits.T3CKPS0 = 1;

    // Enable timer
    T3CONbits.TMR3ON = 1;


    PROJECT_INITIAL_INIT();
}

// ////////////////////////////////////////////////////////////////////////////
// ////////////////////////////////////////////////////////////////////////////

IP_ADDR * ApplGetServerIP(void)
{
    return &_sServerConfig.sSrvAdd.IPAddr;
}

// ////////////////////////////////////////////////////////////////////////////
// ////////////////////////////////////////////////////////////////////////////

NODE_INFO * ApplGetServerNodeInfo(void)
{
    return &_sServerConfig.sSrvAdd;
}

// ////////////////////////////////////////////////////////////////////////////
// ////////////////////////////////////////////////////////////////////////////

WORD_VAL ApplGetServerPort(void)
{
    return _sServerConfig.sPort;
}

// ////////////////////////////////////////////////////////////////////////////
// ////////////////////////////////////////////////////////////////////////////

BOOL ApplIsConnected(void)
{
    return PROJECT_IS_CONNECTED();
}

// ////////////////////////////////////////////////////////////////////////////
// ////////////////////////////////////////////////////////////////////////////

static BOOL disconnect(void)
{
    PROJECT_START_DISCONNECT();
}

// ////////////////////////////////////////////////////////////////////////////
// ////////////////////////////////////////////////////////////////////////////

void ApplStop(void)
{
    InputResetPowerButton();

    while (1)
    {
        if (PIR2bits.CCP2IF == 1)
        {   
            // Reset the timer flag.
            PIR2bits.CCP2IF = 0;
        
            // call the input routines every 10 ms!
            InputMain();
            if (bInputButtonPushed(PWR_BTN) == TRUE)
            {
                break;
            }
        }
    }
}

// ////////////////////////////////////////////////////////////////////////////
// ////////////////////////////////////////////////////////////////////////////

void ApplMain(void)
{
    // Execute the application all 10 ms!
    if (PIR2bits.CCP2IF == 0)
    {
        return;
    }

    // Reset the timer flag.
    PIR2bits.CCP2IF = 0;

    InputMain();


    if (((u16GlobalFlags & SHUTDOWN_MASK) == 0) &&
         (bInputButtonPushedLong(PWR_BTN) == TRUE))
    {
        // Starting shut down sequence...
        ApplShutDown();
    }


    // ////////////////////////////////////////////////////////////////////////
    // Application Task starts here!!!!

    if (u8ApplTimer > 0)
    {
        u8ApplTimer--;
    }

    if (bBootupMain() == FALSE)
    {
        if (u16GlobalFlags & SHUTDOWN_MASK)
        {
            _eApplSM = APPL_SM_SHUTDOWN;
        }
        else
        {
            _eApplSM = APPL_SM_START;
        }
        return;
    }

    if ((_eApplSM>APPL_SM_START)&&(_eApplSM<APPL_SM_WAIT_FOR_USER))
    {
        if (bInputButtonPushed(ENC_BTN) == TRUE)
        {
            _eApplSM = APPL_SM_WAIT_FOR_USER;
        }

        switch(u8ApplTimer)
        {
            case 200:
                OutSetLED(LED_F1, LED_ON);
                OutSetLED(LED_F4, LED_OFF);
                break;

            case 150:
                OutSetLED(LED_F2, LED_ON);
                OutSetLED(LED_F1, LED_OFF);
                break;

            case 100:
                OutSetLED(LED_F3, LED_ON);
                OutSetLED(LED_F2, LED_OFF);
                break;

            case 50:
                OutSetLED(LED_F4, LED_ON);
                OutSetLED(LED_F3, LED_OFF);
                break;

            case 0:
                u8ApplTimer = 201;
                break;
        }

        if(OutIsLCDBusy()==TRUE)
        {
            return;
        }
    }


    switch(_eApplSM)
    {
    case APPL_SM_START:
        if (sPApplConfig.eFindMode == SEARCH_UNKNOWN)
        {
            // The first time or after a factory reset:
            IPSetInit(TRUE);
            _eApplSM = APPL_SM_SERVERSET;
            break;
        }

        StrTbl_GetString(lcdram_row1, STRTBLID_SEARCHING);
        if (sPApplConfig.eFindMode==SEARCH_IP)
        {
            sprintf(lcdram_row2, (ROM char *) "%hhu.%hhu.%hhu.%hhu", 
                    sPApplConfig.sSrvIPAdd.v[0], sPApplConfig.sSrvIPAdd.v[1], 
                    sPApplConfig.sSrvIPAdd.v[2], sPApplConfig.sSrvIPAdd.v[3]);
        }
        else if (sPApplConfig.eFindMode==SEARCH_NAME)
        {
            strcpy(lcdram_row2, sPApplConfig.au8Name);
        }
        else if (sPApplConfig.eFindMode==SEARCH_SERVICE)
        {
            strcpy(lcdram_row2, sPApplConfig.au8Service);
        }

        lcd_addr2 = (16 - strlen(lcdram_row2))>>1;
        lcd_status = LCD_CLR_MASK | LCD_ROW1_MASK |
                     LCD_CENTER1_MASK | LCD_ROW2_MASK;

        // Prepare encoder button for abortion of server search:
        InputButtonReset(ENC_BTN);

        // Prepare the server configuration:
        memset(&_sServerConfig, 0, sizeof(SSERVERNET));
        
        // Init ARP (ARP flush):
        ARPFlush();
        
        u8ApplTimer = 0;

        if (sPApplConfig.eFindMode == SEARCH_IP)
        {   
            _sServerConfig.sSrvAdd.IPAddr.Val = sPApplConfig.sSrvIPAdd.Val;
            _sServerConfig.sPort.Val = sPApplConfig.sIPPort.Val;
             _eApplSM = APPL_SM_RESOLVE_MAC;
            break;
        }

        if (sPApplConfig.eFindMode == SEARCH_SERVICE)
        {
            MDNSResolveService(sPApplConfig.au8Service,(ROM char *) PROJECT_SERVICE_NAME);
        }
        else if (sPApplConfig.eFindMode == SEARCH_NAME)
        {
            MDNSResolveName(sPApplConfig.au8Name);
        }

        _eApplSM = APPL_SM_WAIT_FOR_MDNS_RESOLVE;
        break;

    case APPL_SM_WAIT_FOR_MDNS_RESOLVE:
        if (bMDNSNameIsResolved(&_sServerConfig.sSrvAdd.IPAddr) == TRUE)
        {
            // Successfully resolved the name of the server.
            if (sPApplConfig.eFindMode == SEARCH_SERVICE)
            {
                // A service query also resolves the port of the server!
                bMDNSServiceIsResolved(&_sServerConfig.sSrvAdd.IPAddr, 
                                            &_sServerConfig.sPort);
            }
            else
            {
                _sServerConfig.sPort.Val = sPApplConfig.sNamePort.Val;
            }
            
            _eApplSM = APPL_SM_RESOLVE_MAC;
        }
        break;

    case APPL_SM_RESOLVE_MAC:
        if (MACIsTxReady())
        {
            // Send ARP request
            ARPResolve(&_sServerConfig.sSrvAdd.IPAddr);
            _eApplSM = APPL_SM_WAIT_FOR_SERVER_REPLY;
        }
        break;

    case APPL_SM_WAIT_FOR_SERVER_REPLY:
        if (u8ApplTimer == 1)
        {
            _eApplSM = APPL_SM_RESOLVE_MAC;
        }
        else if (ARPIsResolved(&_sServerConfig.sSrvAdd.IPAddr, 
                               &_sServerConfig.sSrvAdd.MACAddr))
        {
            _eApplSM = APPL_SM_IDLE_CONNECT;
            StrTbl_GetString(lcdram_row1, STRTBLID_CONNECT_TO);
            lcd_status |= LCD_ROW1_MASK | LCD_CENTER1_MASK;
        }
        break;

    case APPL_SM_SERVERSET:
        // Call periodically the IP set menu (Server) and wait for 
        // finish.
        if (IPSetMain() == TRUE)
        {
            _eApplSM = APPL_SM_START;
        }
        break;

    case APPL_SM_IDLE_CONNECT:
        if (u8ApplTimer == 1)
        {
            PROJECT_PREPARE_CONNECTION();

            InputButtonReset(ALL_BTN);
            _eApplSM = APPL_SM_HANDLE_CONNECTION;
        }
        break;

    case APPL_SM_HANDLE_CONNECTION:
    {
        APPL_CONNECTING_RETCODE ret;

        ret = PROJECT_HANDLE_SERVER_CONNECTION();

        if (ret == APPL_CR_ERROR)
        {
            // Errors occured during connect resp. disconnect.
            _eApplSM = APPL_SM_ERROR_CONNECT;
        }
        else if (ret == APPL_CR_CLOSED)
        {
            // Closing of the connection was handled by the application
            // module.
            _eApplSM = APPL_SM_CONNECTION_CLOSED;
        }
        else if (ret == APPL_CR_CONNECTED)
        {
            // Successfully connected to server! Show user:
            StrTbl_GetString(lcdram_row1, STRTBLID_SUCCESSFULLY_CONNECTED);
            sprintf(lcdram_row2, (ROM char *) "%hhu.%hhu.%hhu.%hhu", 
                    _sServerConfig.sSrvAdd.IPAddr.v[0], 
                    _sServerConfig.sSrvAdd.IPAddr.v[1], 
                    _sServerConfig.sSrvAdd.IPAddr.v[2], 
                    _sServerConfig.sSrvAdd.IPAddr.v[3]);

            lcd_status = LCD_CLR_MASK | LCD_ROW1_MASK | LCD_CENTER1_MASK |
                         LCD_ROW2_MASK | LCD_CENTER2_MASK;

            _eApplSM = APPL_SM_CONNECTED;
        }
        break;
    }

    case APPL_SM_CONNECTED:
        if (PROJECT_MAIN() == FALSE)
        {
            _eApplSM = APPL_SM_HANDLE_CONNECTION;
        }
        break;

    case APPL_SM_CONNECTION_CLOSED:
        // Connection was closed. Show user:
        OutSwitchOffAllLEDs();
        StrTbl_GetString(lcdram_row1, STRTBLID_CONNECTION_CLOSED1);
        StrTbl_GetString(lcdram_row2, STRTBLID_CONNECTION_CLOSED2);
        lcd_status = LCD_CLR_MASK | LCD_ROW1_MASK | LCD_CENTER1_MASK |
                     LCD_ROW2_MASK | LCD_CENTER2_MASK;

        InputButtonReset(ALL_BTN);

        if (u16GlobalFlags & SHUTDOWN_MASK)
        {
            _eApplSM = APPL_SM_START_SHUTDOWN;
            u8ApplTimer = 100;
            break;
        }
    
        // Wait for acknowledging user.
        _eApplSM = APPL_SM_WAIT_FOR_USER;
        
        // Intented fall through.

    case APPL_SM_WAIT_FOR_USER:
        OutSwitchOffAllLEDs();

        if (ApplIsConnected())
        {
            InputButtonReset(ALL_BTN);
            disconnect();   
            _eApplSM = APPL_SM_HANDLE_CONNECTION;
            break;
        }   

        if (bInputButtonPushedOnce(ENC_BTN) == TRUE)
        {
            // New server settings:
            IPSetInit(TRUE);
            _eApplSM = APPL_SM_SERVERSET;
        }
        else if(bInputButtonPushedTwice(ENC_BTN)||bInputButtonPushedLong(ENC_BTN))
        {
            // Setting the whole IP data!
            IPSetInit(FALSE);
            BootupSetIP();
            _eApplSM = APPL_SM_START;
        }

        break;

    case APPL_SM_START_SHUTDOWN:
        if ((u8ApplTimer == 0) && (HTTPCheckForIdle() == TRUE))
        {
            // Stop the MDNS service...
            StopMDNSResponder();
            _eApplSM = APPL_SM_SHUTDOWN;
        }
        break;

    case APPL_SM_ERROR_CONNECT:
        StrTbl_GetString(lcdram_row1, STRTBLID_CONNECTION_ERROR1);
        StrTbl_GetString(lcdram_row2, STRTBLID_CONNECTION_ERROR2);
        lcd_status = LCD_CLR_MASK | LCD_ROW1_MASK | LCD_CENTER1_MASK |
                     LCD_ROW2_MASK | LCD_CENTER2_MASK;
        _eApplSM = APPL_SM_WAIT_FOR_USER;
        InputButtonReset(ALL_BTN);
        break;
    }
}

// ////////////////////////////////////////////////////////////////////////////
// ////////////////////////////////////////////////////////////////////////////

void ApplShutDown(void)
{
    if (ApplIsConnected())
    {
        // Before shuting down, all connection will be closed!
        disconnect();
        _eApplSM = APPL_SM_HANDLE_CONNECTION;
    }
    else
    {
        _eApplSM = APPL_SM_START_SHUTDOWN;
        u8ApplTimer = 100;
    }

    // Remember the shutdown request.
    u16GlobalFlags |= SHUTDOWN_MASK;
}

// ////////////////////////////////////////////////////////////////////////////
// ////////////////////////////////////////////////////////////////////////////

BOOL ApplIsRunning(void)
{
    if (_eApplSM == APPL_SM_SHUTDOWN)
    {
        return FALSE;
    }
    else
    {
        return TRUE;
    }
}

// ////////////////////////////////////////////////////////////////////////////
// ////////////////////////////////////////////////////////////////////////////

void ApplResetToFactory(BOOL KeepBootup)
{
    BYTE * confPtr = (BYTE *)(&sPApplConfig);

    // Erase the EEPROM before rewriting the standard settings:
    XEEEraseEEPROM();


    // Restore BOOTUP!
    if (KeepBootup == TRUE)
    {
        BootupRestoreState();
    }
    else
    {
        BootupResetToFactory();
    }

    // Restoring application specific network data:
    sPApplConfig.sSrvIPAdd.v[0] = 192;
    sPApplConfig.sSrvIPAdd.v[1] = 168;
    sPApplConfig.sSrvIPAdd.v[2] = 1;
    sPApplConfig.sSrvIPAdd.v[3] = 1;
    sPApplConfig.sIPPort.Val = PROJECT_DEFAULT_PORT;
    sPApplConfig.sNamePort.Val = sPApplConfig.sIPPort.Val;
    sPApplConfig.eFindMode = SEARCH_UNKNOWN;
    memset(sPApplConfig.au8Name, 0, sizeof(sPApplConfig.au8Name));
    memset(sPApplConfig.au8Service, 0, sizeof(sPApplConfig.au8Service));
    sPApplConfig.sFlags.bToggleLocoDirMode = TOGGLEDIRMODE_CLICK;

    XEEWriteArray(APPL_EEPROM_ADD, confPtr, sizeof(SPAPPLDATA));


    // Restore application related:
    PROJECT_RESET_TO_FACTORY();
}

// ////////////////////////////////////////////////////////////////////////////
// ////////////////////////////////////////////////////////////////////////////

void ApplChangeLocoDirMode(BOOL Mode)
{
    if (Mode != sPApplConfig.sFlags.bToggleLocoDirMode)
    {
        sPApplConfig.sFlags.bToggleLocoDirMode = Mode;
        XEEWriteArray(APPL_EEPROM_ADD,(BYTE *)(&sPApplConfig), sizeof(SPAPPLDATA));

        PROJECT_LOCO_DIR_MODE_HAS_CHANGED();
    }
}

// ////////////////////////////////////////////////////////////////////////////
// ////////////////////////////////////////////////////////////////////////////

void ApplRestart(BOOL ResetToFactory)
{
    if ((u16GlobalFlags & SHUTDOWN_MASK) == 0)
    {
        if (ResetToFactory == TRUE)
        {
            // Reset to factory settings requested
            u16GlobalFlags |= FACRES_MASK;
        }
        else
        {
            // Restart requested
            u16GlobalFlags |= RESTART_MASK;
        }

        StopMDNSResponder();
        ApplShutDown();
    }
}

// ////////////////////////////////////////////////////////////////////////////
// ////////////////////////////////////////////////////////////////////////////

---