bootup.c

Go to the documentation of this file.

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


// ////////////////////////////////////////////////////////////////////////////
// Local Includes
// ////////////////////////////////////////////////////////////////////////////

    #define     BOOTUP_C
    #include    "bootup.h"
    #include    "mdns.h"
    #include    "TCPIP.h"
    #include    "stringtable.h"
    #include    "sralloc.h"

    #include    "projectdefs.h"


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

// States of bootup
typedef enum
{
    BOOTUP_SM_STARTUP = 0,
    BOOTUP_SM_STARTUP_WAIT,
    BOOTUP_SM_STARTUP_LANGUAGE,
    BOOTUP_SM_STARTUP_FINI,
    BOOTUP_SM_IPSET,
    BOOTUP_SM_NOLINK,
    BOOTUP_SM_NOLINK_WAIT,
    BOOTUP_SM_WAIT_FOR_IP,
    BOOTUP_SM_START_CHECK_IP,
    BOOTUP_SM_CHECK_IP,
    BOOTUP_SM_IP_ERROR,
    BOOTUP_SM_SHOW_IP_ERROR,
    BOOTUP_SM_DISPLAY_IPDATA,
    BOOTUP_SM_WAIT_FOR_USER,
    BOOTUP_SM_WAIT_FOR_NAMESERVICE,
    BOOTUP_SM_WAIT_FOR_USER2,
    BOOTUP_SM_READY
} SM_BOOTUP;


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

// ////////////////////////////////////////////////////////////////////////////
// Local Variables
// ////////////////////////////////////////////////////////////////////////////

static SM_BOOTUP _eBootUpSM;

static BOOL _bFirstTime;    


static BYTE _au8NetworkDataForBootloader[12];


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

static void BootupCheckVersionTag(void);


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

void BootupInit(void)
{
    _bFirstTime = TRUE;
    _eBootUpSM = BOOTUP_SM_STARTUP;


    // ////////////////////////////////////////////////////////////////////////
    // IP level

    // Get the common and network related data from external EEPROM:
    {
        XEEReadArray(BOOTUP_EEPROM_ADD, (BYTE *)(&sPCommonConfig), sizeof(PCOMMON_CONFIG));
    }


    // Check, if any updates have been done and the EEPROM data must be 
    // updated somehow.
    BootupCheckVersionTag();


    // ////////////////////////////////////////////////////////////////////////
    // DHCP level

    if (sPCommonConfig.Flags.bIsDHCPEnabled == TRUE)
    {
        // Starting automatic IP discovery (including AutoIP if DHCP fails).
        DHCPEnable();
        DHCPReset(FALSE);
    }
    else
    {
        // Starting manual IP discovery...
        DHCPDisable();
        sIPConfig.MyIPAddr.Val = sPCommonConfig.ManIPAddr.Val;
        sIPConfig.MyMask.Val = IPConvertSubnetToMask(sPCommonConfig.ManMask);
        sIPConfig.MyGateway.Val = sPCommonConfig.ManGateway.Val;
        sIPConfig.Flags.bIPunique = FALSE;
    }
}


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

void BootupSetIP(void)
{
    // Entering the IP set menu.
    _eBootUpSM = BOOTUP_SM_IPSET;
}

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

BOOL bBootupMain(void)
{
    // Reset the application if the network connection is lost.
    if ((_eBootUpSM > BOOTUP_SM_NOLINK_WAIT) && (MACIsLinked()) == 0) 
    {
        OutSwitchOffAllLEDs();
        u16GlobalFlags &= ~(LINKISUP_MASK); // Stop executing TCP/IP stack.
        _eBootUpSM = BOOTUP_SM_NOLINK;
        // Reset the heap!
        SRAMInitHeap();
    }


    // ////////////////////////////////////////////////////////////////////////
    // The State Machine implementation.

    switch(_eBootUpSM)
    {
    case BOOTUP_SM_STARTUP:
        // Display the startup string and waiting for some time. In this time
        // also the physical network layer comes up.

        strcpypgm2ram(lcdram_row1, (ROM char *) "eWicht " PROJECT_NAME);

        strcpypgm2ram(lcdram_row2, (ROM char *) FIRMWARE_VERSION_STRING);
        lcd_status = LCD_CLR_MASK | LCD_ROW1_MASK | LCD_CENTER1_MASK |
                     LCD_ROW2_MASK | LCD_CENTER2_MASK;

        if (_bFirstTime == TRUE)
        {
            u8ApplTimer = 250;  // Wait 2.5 seconds.
        }
        else
        {
            u8ApplTimer = 50;   // Wait 0.5 seconds.
        }
        
        InputButtonReset(ENC_BTN);
        _eBootUpSM = BOOTUP_SM_STARTUP_WAIT;
        // Intented fall through.

    case BOOTUP_SM_STARTUP_WAIT:
        // Switch on all the LEDs in a serial fashion for testing purposes.
        // Go to the next state if the intitial wait time is over.

#ifndef DEBEXT_MODE
        if (_bFirstTime == TRUE)
        { 
            switch (u8ApplTimer)
            {
            case 250:
                OutSetLED(LED_ACC, LED_ON);
                break;

            case 240:
                OutSetLED(LED_FL, LED_ON);
                break;

            case 230:
                OutSetLED(LED_F1, LED_ON);
                break;

            case 220:
                OutSetLED(LED_F2, LED_ON);
                break;

            case 210:
                OutSetLED(LED_F3, LED_ON);
                break;

            case 200:
                OutSetLED(LED_F4, LED_ON);
                break;

            case 190:
                OutSetLED(LED_PWR, LED_ON);
                break;

            case 180:
                OutSetLED(LED_SEL, LED_ON);
                break;

            case 170:
                OutSetLED(LED_ACC, LED_OFF);
                break;

            case 160:
                OutSetLED(LED_FL, LED_OFF);
                break;

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

            case 140:
                OutSetLED(LED_F2, LED_OFF);
                break;

            case 130:
                OutSetLED(LED_F3, LED_OFF);
                break;

            case 120:
                OutSetLED(LED_F4, LED_OFF);
                break;

            case 110:
                OutSetLED(LED_PWR, LED_OFF);
                break;

            case 100:
                OutSetLED(LED_SEL, LED_OFF);
                break;
            }
        }
#endif
        
        if (u8ApplTimer == 0)
        {
            if (sPCommonConfig.u8LanguageID != LANGID_NOTSPECIFIED)
            {
                // Valid language configured, go ahead.
                StrTbl_SetLanguage(sPCommonConfig.u8LanguageID);
                _eBootUpSM = BOOTUP_SM_STARTUP_FINI;
                break;
            }
    
            InputEncoderInit(0, 0, LANGID_MAX, 0);
            _eBootUpSM = BOOTUP_SM_STARTUP_LANGUAGE;
        }
        break;

    case BOOTUP_SM_STARTUP_LANGUAGE:
        if (bInputButtonPushed(ENC_BTN)||bInputButtonPushed(F4_BTN))
        {
            // Language dialog was finished!
            sPCommonConfig.u8LanguageID = (BYTE)s16InputEncoderGetValue();
            // Write the new language ID to the EEPROM:
            XEEWriteArray(BOOTUP_EEPROM_ADD, (BYTE *)&sPCommonConfig, sizeof(PCOMMON_CONFIG));
            InputButtonReset(ENC_BTN);
            _eBootUpSM = BOOTUP_SM_STARTUP_FINI;
        }
        else if (bInputEncoderValueChanged() == TRUE)
        {
            strcpypgm2ram(lcdram_row1, (ROM char *) "eWicht");
            StrTbl_SetLanguage((BYTE)s16InputEncoderGetValue());
            StrTbl_GetString(lcdram_row2, STRTBLID_LANGUAGE_NAME);
            lcd_status = LCD_CLR_MASK | LCD_ROW1_MASK | LCD_CENTER1_MASK | LCD_ROW2_MASK | LCD_CENTER2_MASK;
        }
        break;

    case BOOTUP_SM_STARTUP_FINI:
        // Mark this session as booted:
        _bFirstTime = FALSE;
        StackInit();
        bInitMDNSResponder();   // Initialize the MDNS Responder.
        u16GlobalFlags |= LINKISUP_MASK;    // Start executing TCP/IP stack.

        if (bInputButtonPushed(ENC_BTN) == TRUE)
        {
            // User pushed the encoder button -> Entering the IP menu.
            IPSetInit(FALSE);
            _eBootUpSM = BOOTUP_SM_IPSET;
        }
        else if (sPCommonConfig.Flags.bIsDHCPEnabled == TRUE)
        {
            // Inform the user about the enabled DHCP and the starting
            // discovery.
            StrTbl_GetString(lcdram_row1, STRTBLID_ALLOCATE);
            StrTbl_GetString(lcdram_row2, STRTBLID_IP_ADDRESS);

            lcd_status = LCD_CLR_MASK | LCD_ROW1_MASK | LCD_CENTER1_MASK |
                    LCD_ROW2_MASK | LCD_CENTER2_MASK | LCD_PROGRESS_MASK;
            _eBootUpSM = BOOTUP_SM_WAIT_FOR_IP;
            InputButtonReset(ENC_BTN);
        }
        else
        {
            // IP Address was manual set by user...
            _eBootUpSM = BOOTUP_SM_START_CHECK_IP;
        }
        break;

    case BOOTUP_SM_WAIT_FOR_IP:
        if (bInputButtonPushed(ENC_BTN) == TRUE)
        {
            // During the discovery phase the user has the possibility to enter
            // the IP menu.
            IPSetInit(FALSE);
            _eBootUpSM = BOOTUP_SM_IPSET;
            break;
        }

        if (DHCPIsBound())
        {
            // The DHCP discovery phase was successful. No IP check is needed
            // here.
    
            // Starting the MDNS service.
            StartMDNSResponder();
            _eBootUpSM = BOOTUP_SM_DISPLAY_IPDATA;
        }
        else if (sIPConfig.MyIPAddr.Val)
        {
            // AUTO-IP (DHCP discovery not successful). Check the choosen IP 
            // for uniqueness.
            _eBootUpSM = BOOTUP_SM_START_CHECK_IP;
        }
        break;

    case BOOTUP_SM_START_CHECK_IP:
        // Gracious ARP phase. Checking for the uniqueness of the choosen IP
        // address (only needed if the IP address was choosen manually or by
        // AutoIP). 
        // Sending three ARP requests to the choosen IP and waiting for 
        // answers. If receiving an answer the gracious ARP phase fails.
        if (sIPConfig.Flags.bIPunique == TRUE)
        {
            _eBootUpSM = BOOTUP_SM_DISPLAY_IPDATA;
            break;
        }
        else
        {
            u8ApplTimer = 255;
            _eBootUpSM = BOOTUP_SM_CHECK_IP;
        }
        // Intented fall through.

    case BOOTUP_SM_CHECK_IP:
        // Do three gracious ARP for ensuring that IP is unique.
        {
            MAC_ADDR dummy;
            if (u8ApplTimer == 0)
            {
                // Gracious ARP time is over.

                // The uniqness of IP is ensured!
                sIPConfig.Flags.bIPunique = TRUE;

                // Starting the MDNS service.
                StartMDNSResponder();

                // Displaying the choosen IP Address to the user. 
                _eBootUpSM = BOOTUP_SM_DISPLAY_IPDATA;
                break;
            }

            if (ARPIsResolved(&sIPConfig.MyIPAddr, &dummy) == FALSE)
            {
                // ARP is still not resolved! That is good. 
                switch(u8ApplTimer)
                {
                case 255:   // 2.55 seconds to go
                case 192:   // 1.92 seconds to go
                case 129:   // 1.29 seconds to go
                    ARPResolve(&sIPConfig.MyIPAddr);
                }
            }
            else
                // Got an answer! Gracious ARP failed.
                _eBootUpSM = BOOTUP_SM_SHOW_IP_ERROR;

            break;
        }

    case BOOTUP_SM_SHOW_IP_ERROR:
        // An IP related error has occured. 

        // Disable the IP address!!!
        sIPConfig.MyIPAddr.Val = 0;
        sIPConfig.MyMask.Val = 0;
        sIPConfig.MyGateway.Val = 0;

        // Show the error to the user.
        StrTbl_GetString(lcdram_row1, STRTBLID_ADDRESS_CONFLICT1);
        StrTbl_GetString(lcdram_row2, STRTBLID_ADDRESS_CONFLICT2);
        lcd_status = LCD_CLR_MASK | LCD_ROW1_MASK | LCD_CENTER1_MASK |
                    LCD_ROW2_MASK | LCD_CENTER2_MASK;

        InputButtonReset(ENC_BTN);
        _eBootUpSM = BOOTUP_SM_IP_ERROR;        
        break;

    case BOOTUP_SM_IP_ERROR:
        // Waiting for user acknowledgement of the error. After the push of the
        // rotary encoder the IP menu is entered.
        if (bInputButtonPushed(ENC_BTN) == TRUE)
        {
            IPSetInit(FALSE);
            _eBootUpSM = BOOTUP_SM_IPSET;
        }
        break;

    case BOOTUP_SM_IPSET:
        // Call the IP menu periodically:
        if (IPSetMain() == TRUE)
        {
            // Restart the application...
            _eBootUpSM = BOOTUP_SM_STARTUP;
        }
        break;

    case BOOTUP_SM_NOLINK:
        // A network connection is lost (PHY layer). Show this to the user.
        StrTbl_GetString(lcdram_row1, STRTBLID_CABEL_UNPLUGGED1);
        StrTbl_GetString(lcdram_row2, STRTBLID_CABEL_UNPLUGGED2);
        lcd_status = LCD_CLR_MASK | LCD_ROW1_MASK | LCD_CENTER1_MASK |
                     LCD_ROW2_MASK | LCD_CENTER2_MASK;
        _eBootUpSM = BOOTUP_SM_NOLINK_WAIT;
        break;

    case BOOTUP_SM_NOLINK_WAIT:
        // The eWicht is in a state without a network connection (PHY layer).
        // With a push of the rotary encoder the IP menu is entered. A detected
        // network connection leads to the normal bootup state.
        if (bInputButtonPushed(ENC_BTN) == TRUE)
        {
            IPSetInit(FALSE);
            _eBootUpSM = BOOTUP_SM_IPSET;
        }
        else if (MACIsLinked())
        {
            if (sPCommonConfig.Flags.bIsDHCPEnabled)
            {
                DHCPReset(FALSE);
            }
            else
            {
                sIPConfig.Flags.bIPunique = FALSE;
            }
    
            _eBootUpSM = BOOTUP_SM_STARTUP;
        }
        break;

    case BOOTUP_SM_DISPLAY_IPDATA:
        // In case the IP was obtained automatically (via DHCP or AutoIP), the
        // IP is shown to the user.
        if (sPCommonConfig.Flags.bIsDHCPEnabled == TRUE)
        {
            StrTbl_GetString(lcdram_row1, STRTBLID_OBTAINED_IP);
        }
        else
        {
            StrTbl_GetString(lcdram_row1, STRTBLID_MANUAL_IP);  
        }

        sprintf(lcdram_row2, (ROM char *) "%hhu.%hhu.%hhu.%hhu", 
                        sIPConfig.MyIPAddr.v[0], sIPConfig.MyIPAddr.v[1], 
                        sIPConfig.MyIPAddr.v[2], sIPConfig.MyIPAddr.v[3]);
        lcd_addr2 = 0;
        lcd_status = LCD_CLR_MASK | LCD_ROW1_MASK | LCD_CENTER1_MASK | 
                     LCD_CENTER2_MASK | LCD_ROW2_MASK;

        InputButtonReset(ENC_BTN);
        u8ApplTimer = 250;
        _eBootUpSM = BOOTUP_SM_WAIT_FOR_USER;
        break;

    case BOOTUP_SM_WAIT_FOR_USER:
        if ((u8ApplTimer == 0) || (bInputButtonPushed(ENC_BTN) == TRUE))
        {
            _eBootUpSM = BOOTUP_SM_WAIT_FOR_NAMESERVICE;
        }
        break;

    case BOOTUP_SM_WAIT_FOR_NAMESERVICE:
        if(eGetMDNSState() == MDNS_HAS_STOPPED)
        {
            // Nameserver has stopped! Thats bad but the eWicht will work
            // anyway. Display to user, that nameserver could not be 
            // started. Connection to the eWicht via its name is not 
            // possible than.
            // A reason for this can be that another device in the network
            // has the same name.

            StrTbl_GetString(lcdram_row1, STRTBLID_NAMESERVICE);
            StrTbl_GetString(lcdram_row2, STRTBLID_STOPPED);
            lcd_status = LCD_CLR_MASK | LCD_ROW1_MASK | LCD_CENTER1_MASK |
                         LCD_ROW2_MASK | LCD_CENTER2_MASK;

            InputButtonReset(ENC_BTN);
            u8ApplTimer = 250;
            _eBootUpSM = BOOTUP_SM_WAIT_FOR_USER2;
        }
        else if(eGetMDNSState() == MDNS_IS_RUNNING)
        {
            _eBootUpSM = BOOTUP_SM_READY;
        }

        break;

    case BOOTUP_SM_WAIT_FOR_USER2:
        if ((u8ApplTimer == 0) || (bInputButtonPushed(ENC_BTN) == TRUE))
        {
            _eBootUpSM = BOOTUP_SM_READY;
        }
        break;

    case BOOTUP_SM_READY:
        // The boot up is finished. Indicate this to the calling application.
        return TRUE;
    }

    return FALSE;
}

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

void BootupEnterBootloader(void)
{
    // Fetch the MAC address from MAC module.
    memcpypgm2ram(_au8NetworkDataForBootloader, pu8MAC, 6);
    memcpy((void *)&_au8NetworkDataForBootloader[6], (void *)&sIPConfig.MyIPAddr, 4);
    *(WORD *)(&_au8NetworkDataForBootloader[10]) = CalcIPChecksum(_au8NetworkDataForBootloader, 6+4);

    PROD = (WORD) _au8NetworkDataForBootloader;
}

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

void BootupRestoreState(void)
{
    // Write the bulk of new data to the web EEPROM:
    XEEWriteArray(BOOTUP_EEPROM_ADD, (BYTE *)(&sPCommonConfig), sizeof(PCOMMON_CONFIG));
}

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

void BootupResetToFactory(void)
{
    int i = 0;

    // Restoring IP specific data:

    // The DHCP Flag automatically resets MyIPAddr, MyMask and MyGateway to 0
    // in the application.
    sPCommonConfig.Flags.bIsDHCPEnabled = TRUE;
    
    sPCommonConfig.ManIPAddr.v[0] = 192;
    sPCommonConfig.ManIPAddr.v[1] = 168;
    sPCommonConfig.ManIPAddr.v[2] = 0;
    sPCommonConfig.ManIPAddr.v[3] = 10;
    sPCommonConfig.ManMask = 24;
    sPCommonConfig.ManGateway.v[0] = 192;
    sPCommonConfig.ManGateway.v[1] = 168;
    sPCommonConfig.ManGateway.v[2] = 0;
    sPCommonConfig.ManGateway.v[3] = 1;

    sPCommonConfig.LastAutoIP = GenerateAutoIP(0);

    sPCommonConfig.u8LCDLight = 20;

    sPCommonConfig.u32VersionTag = FIRMWARE_VERSION;

    sPCommonConfig.TargetProject = PROJECT_ID;

    // The user selects the language at eWicht after a restart:
    sPCommonConfig.u8LanguageID = 0xFF; 

    BootupRestoreState();
}

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

static void BootupCheckVersionTag(void)
{
    if (sPCommonConfig.u32VersionTag == 0xFFFFFFFF)
    {
        // Indicator for first time being here (first switch on with an empty
        // EEPROM)! Filling the EEPROM with typical application data:
        ApplResetToFactory(FALSE);
    }
    else if (sPCommonConfig.u32VersionTag < FIRMWARE_VERSION)
    {
        // This EEPROM is from an old version (older than this).

        // Migrate!
        sPCommonConfig.u32VersionTag = FIRMWARE_VERSION;
        XEEWriteArray(BOOTUP_EEPROM_ADD+offsetof(PCOMMON_CONFIG, u32VersionTag), (BYTE *)&sPCommonConfig.u32VersionTag, 4);
    }
    
    if (sPCommonConfig.TargetProject != PROJECT_ID)
    {
        // Trying to preserve the boot data:
        sPCommonConfig.TargetProject = PROJECT_ID;

        // This EEPROM content is from another target.
        ApplResetToFactory(TRUE);
    }
}

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

---