TIVA,TM4C1294NCPDT, NDK run-time configuration of Static and Dynamic IP

Hi Suresh,

Sorry for the delayed response.

If I am understanding you correctly, it seems like you would like to be able to determine whether to configure static or dynamic IP based on an input.  By default, NDK will initialize it in either static or dynamic based on your *.cfg file configuration, this all happens in the NDK stack thread.  

I think the best approach for what you want to accomplish is to write your own NDK stack thread.  In this thread, you can pend until you get the input to be static or dynamic IP.  To configure you custom NDK stack thread you must add the following to your *.cfg file:

/* Set user thread for NDK */
Global.stackThreadUser = "&userNdkStackThread";

Below I took the NDK stack thread from the TI-RTOS tcpEcho example and added comments to what you can modify:

Void userNdkStackThread(UArg arg0, UArg arg1)
{
    int rc;
    HANDLE hCfg;

    ti_sysbios_knl_Clock_Params clockParams;

    /* Create the NDK heart beat */
    ti_sysbios_knl_Clock_Params_init(&clockParams);
    clockParams.startFlag = TRUE;
    clockParams.period = 100;
    ti_sysbios_knl_Clock_create(&llTimerTick, clockParams.period, &clockParams, NULL);

    /* THIS MUST BE THE ABSOLUTE FIRST THING DONE IN AN APPLICATION!! */
    rc = NC_SystemOpen(NC_PRIORITY_LOW, NC_OPMODE_INTERRUPT);
    if (rc) {
        xdc_runtime_System_abort("NC_SystemOpen Failed (%d)\n");
    }

    /* Create and build the system configuration from scratch. */
    hCfg = CfgNew();
    if (!hCfg) {
        xdc_runtime_System_printf("Unable to create configuration\n");
        goto main_exit;
    }

    /* Pend on a semaphore until you know if you want static or dynamic IP */
    Semaphore_pend(ipBlockingSem, BIOS_WAIT_FOREVER);

    /* add the IP module configuration settings. */
    if (staticIP) {
        /* THIS IS COPIED FROM ti_ndk_config_ip_init(hCfg) WHEN CONFIGURED FOR STATIC IP */
        /* Configure IP address manually on interface 1 */
        {
            CI_IPNET NA;
            CI_ROUTE RT;
            /* Setup manual IP address */
            bzero(&NA, sizeof(NA));
            NA.IPAddr  = inet_addr(LocalIPAddr);
            NA.IPMask  = inet_addr(LocalIPMask);
            strcpy(NA.Domain, DomainName);
            NA.NetType = 0;

            CfgAddEntry(hCfg, CFGTAG_IPNET, 1, 0,
                    sizeof(CI_IPNET), (UINT8 *)&NA, 0);

            /*
             *  Add the default gateway. Since it is the default, the
             *  destination address and mask are both zero (we go ahead
             *  and show the assignment for clarity).
             */
            bzero(&RT, sizeof(RT));
            RT.IPDestAddr = 0;
            RT.IPDestMask = 0;
            RT.IPGateAddr = inet_addr(GatewayIP);

            CfgAddEntry(hCfg, CFGTAG_ROUTE, 0, 0,
                    sizeof(CI_ROUTE), (UINT8 *)&RT, 0);
        }
    }
    else {
        /* THIS IS COPIED FROM ti_ndk_config_ip_init(hCfg) WHEN CONFIGURED FOR DYNAMIC IP */
        /* Use DHCP to obtain IP address on interface 1 */
        {
            CI_SERVICE_DHCPC dhcpc;
            UINT8 DHCP_OPTIONS[] = {
                DHCPOPT_SUBNET_MASK,
            };

            /* Specify DHCP Service on IF specified by "IfIdx" */
            bzero(&dhcpc, sizeof(dhcpc));
            dhcpc.cisargs.Mode   = 1;
            dhcpc.cisargs.IfIdx  = 1;
            dhcpc.cisargs.pCbSrv = &ti_ndk_config_Global_serviceReport;
            dhcpc.param.pOptions = DHCP_OPTIONS;
            dhcpc.param.len = 1;
            CfgAddEntry(hCfg, CFGTAG_SERVICE, CFGITEM_SERVICE_DHCPCLIENT, 0,
                    sizeof(dhcpc), (UINT8 *)&dhcpc, 0);
        }
    }

    /* add the Tcp module configuration settings. */
    ti_ndk_config_tcp_init(hCfg);

    /* add the Udp module configuration settings. */
    ti_ndk_config_udp_init(hCfg);

    /* add the configuration settings for NDK low priority tasks stack size. */
    rc = 1024;
    CfgAddEntry(hCfg, CFGTAG_OS, CFGITEM_OS_TASKSTKLOW,
                 CFG_ADDMODE_UNIQUE, sizeof(uint), (UINT8 *)&rc, 0 );

    /* add the configuration settings for NDK norm priority tasks stack size. */
    rc = 1024;
    CfgAddEntry(hCfg, CFGTAG_OS, CFGITEM_OS_TASKSTKNORM,
                 CFG_ADDMODE_UNIQUE, sizeof(uint), (UINT8 *)&rc, 0 );

    /* add the configuration settings for NDK high priority tasks stack size. */
    rc = 1024;
    CfgAddEntry(hCfg, CFGTAG_OS, CFGITEM_OS_TASKSTKHIGH,
                 CFG_ADDMODE_UNIQUE, sizeof(uint), (UINT8 *)&rc, 0 );

    /*
     *  Boot the system using this configuration
     *
     *  We keep booting until the function returns 0. This allows
     *  us to have a "reboot" command.
    */
    do
    {
        rc = NC_NetStart(hCfg, ti_ndk_config_Global_NetworkOpen, 
                         ti_ndk_config_Global_NetworkClose, 
                         ti_ndk_config_Global_NetworkIPAddr);

    } while( rc > 0 );

    /* Delete Configuration */
    CfgFree(hCfg);

    /* Close the OS */
main_exit:
    NC_SystemClose();
    xdc_runtime_System_flush();

}

Hope this helps,

-- Emmanuel