TM4C1294NCPDT: Writing variable value in flash -Tirtos Tm4c1294

/*
 * Copyright (c) 2014, Texas Instruments Incorporated
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * *  Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 *
 * *  Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * *  Neither the name of Texas Instruments Incorporated nor the names of
 *    its contributors may be used to endorse or promote products derived
 *    from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS 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 THE COPYRIGHT OWNER OR
 * 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.
 */

/*
 *    ======== tcpEcho.c ========
 */

/* XDCtools Header files */
#include <xdc/std.h>
#include <xdc/cfg/global.h>
#include <ti/sysbios/hal/Hwi.h>

#include <xdc/runtime/Error.h>
#include <xdc/runtime/Memory.h>
#include <xdc/runtime/System.h>

/* BIOS Header files */
#include <ti/sysbios/BIOS.h>
#include <ti/sysbios/knl/Clock.h>
#include <ti/sysbios/knl/Task.h>

 /* NDK Header files */
#include <ti/ndk/inc/netmain.h>
#include <ti/ndk/inc/_stack.h>

/* TI-RTOS Header files */
#include <ti/drivers/GPIO.h>

/* Example/Board Header files */
#include "Board.h"

#include <stdint.h>
#include <stdio.h>
#include <stdbool.h>
#include <time.h>

#include "inc/hw_types.h"
#include "inc/hw_memmap.h"
#include "driverlib/sysctl.h"
#include "inc/hw_gpio.h"
#include "driverlib/gpio.h"
#include "inc/hw_ints.h"
#include "driverlib/interrupt.h"
#include "driverlib/timer.h"
#include "driverlib/pin_map.h"
//#include "driverlib/rom.h"
//#include "driverlib/rom_map.h"

#include "driverlib/udma.h"
#include "inc/hw_udma.h"
#include "inc/hw_adc.h"
#include "driverlib/adc.h"

#include "inc/hw_flash.h"
#include "driverlib/flash.h"

#define dma false




#define FLASH_BASE_ADDR        (0x1FFFE000)



#define SIZE_N 1000
#define SIZE_HN 500
//============================Ethernet ========================//

#define TCPPACKETSIZE 1024
#define TCPPORT 8080
#define NUMTCPWORKERS 3




//============================ETHERNET INITS========================//
uint32_t g_ui32SysClock;
//============================================================//

SOCKET lSocket;
struct sockaddr_in sLocalAddr;
char  mydata[23];
//============================================================//

//============================ADC INITS ========================//
#define ADC_SAMPLE_BUF_SIZE (1)

//   uint32_t ui32Config, ui32ClockDiv;  //for ADC Clock test
uint32_t udmaCtrlTable[1024] __attribute__ ((aligned(1024)));
uint32_t ADC_OUT_1[6],ADC_OUT_2[6];

uint8_t DIGI_IO;
bool  PSFLT,ARC,IDSLW,TEMP,MAIN_IN;
//   uint16_t RF_FORWARD,RF_REVERSE,TEMPERATURE,VDS,ID,VGS;
//============================================================//

uint16_t RF_FORWARD[SIZE_N],RF_REVERSE[SIZE_N],TEMPERATURE[SIZE_N],VDS[SIZE_N],ID[SIZE_N],VGS[SIZE_N];
uint8_t DIGI_BUFF[SIZE_N];
uint16_t flash_counter;
int error;


uint8_t VDS_count=0,ID_count=0,RF_count=0;
uint16_t TEMP_count=0;

bool LOCK=false;

uint8_t counter=0;

uint32_t gp_count;

void gpioButtonFxn0(unsigned int index)
{
    /* Clear the GPIO interrupt and toggle an LED */
    ARC=1;
    gp_count++;
    //GPIO_toggle(Board_LED1);
    sprintf(mydata,"*D01$DGI$%d#",DIGI_IO);
    send(lSocket, (char *)mydata,sizeof(mydata), 0 );

}

#if dma

void ADCSeq0Handler(void)
 {
     // Clear the Interrupt Flag.

     ADCIntClear(ADC0_BASE, 0);

  //   uint32_t ui32Mode = uDMAChannelModeGet(UDMA_CHANNEL_ADC0);
     if(  uDMAChannelModeGet(UDMA_CHANNEL_ADC0|UDMA_PRI_SELECT) == 0)
     {
        // GPIOPinWrite(GPIO_PORTH_BASE, GPIO_PIN_3, 0x08);
         uDMAChannelTransferSet(UDMA_CHANNEL_ADC0 | UDMA_PRI_SELECT,UDMA_MODE_PINGPONG,(void *)(ADC0_BASE + ADC_O_SSFIFO0), ADC_OUT_1,6);
         uDMAChannelEnable(UDMA_CHANNEL_ADC0|UDMA_PRI_SELECT);
         counter++;
       // GPIOPinWrite(GPIO_PORTH_BASE, GPIO_PIN_3, 0x00);
     }
     if(  uDMAChannelModeGet(UDMA_CHANNEL_ADC0|UDMA_ALT_SELECT) == 0)
     {
        // GPIOPinWrite(GPIO_PORTH_BASE, GPIO_PIN_3, 0x08);
         uDMAChannelTransferSet(UDMA_CHANNEL_ADC0 | UDMA_ALT_SELECT, UDMA_MODE_PINGPONG,(void *)(ADC0_BASE + ADC_O_SSFIFO0),ADC_OUT_2,6);
         uDMAChannelEnable(UDMA_CHANNEL_ADC0|UDMA_ALT_SELECT);
        // GPIOPinWrite(GPIO_PORTH_BASE, GPIO_PIN_3, 0x00);
     }
}
#endif
 void InitUDMA(void)
 {


         uDMAEnable(); // Enables uDMA
         uDMAControlBaseSet(udmaCtrlTable);
         //IntEnable(INT_UDMA);
         uDMAChannelAttributeDisable(UDMA_CHANNEL_ADC0, UDMA_ATTR_ALL);

         // Configures the base address of the channel control table. Table resides in system memory and holds control
             //     information for each uDMA channel. Table must be aligned on a 1024-byte boundary. Base address must be
             //     configured before any of the channel functions can be used
         uDMAChannelAttributeEnable(UDMA_CHANNEL_ADC0, UDMA_ATTR_USEBURST );


        uDMAChannelControlSet(UDMA_CHANNEL_ADC0 | UDMA_PRI_SELECT, UDMA_SIZE_32 | UDMA_SRC_INC_NONE | UDMA_DST_INC_32 | UDMA_NEXT_USEBURST |UDMA_CHCTL_ARBSIZE_1);
        uDMAChannelControlSet(UDMA_CHANNEL_ADC0 | UDMA_ALT_SELECT, UDMA_SIZE_32 | UDMA_SRC_INC_NONE | UDMA_DST_INC_32 | UDMA_NEXT_USEBURST |UDMA_CHCTL_ARBSIZE_1);

        uDMAChannelTransferSet(UDMA_CHANNEL_ADC0 | UDMA_PRI_SELECT, UDMA_MODE_PINGPONG,(void *)(ADC0_BASE + ADC_O_SSFIFO0), ADC_OUT_1, 6);
        uDMAChannelTransferSet(UDMA_CHANNEL_ADC0 | UDMA_ALT_SELECT, UDMA_MODE_PINGPONG,(void *)(ADC0_BASE + ADC_O_SSFIFO0),ADC_OUT_2,6);


        uDMAChannelEnable(UDMA_CHANNEL_ADC0);
        //uDMAChannelRequest(UDMA_CHANNEL_ADC0);


#if dma
        ADCIntEnableEx(ADC0_BASE, ADC_INT_DMA_SS0); // Enables ADC interrupt source due to DMA on ADC sample sequence 0
//        IntEnable(INT_ADC0SS0);
        ADCIntRegister(ADC0_BASE,0,ADCSeq0Handler);

       IntMasterEnable();
#endif

 }

 void InitConsole(void)
 {
        SysCtlPeripheralReset(SYSCTL_PERIPH_ADC0);
        SysCtlPeripheralEnable(SYSCTL_PERIPH_ADC0);

        SysCtlPeripheralReset(SYSCTL_PERIPH_UDMA);
        SysCtlPeripheralEnable(SYSCTL_PERIPH_UDMA);

        SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOE);
        GPIOPinTypeADC(GPIO_PORTE_BASE, GPIO_PIN_3);            //RF_FORWARD
        GPIOPinTypeADC(GPIO_PORTE_BASE, GPIO_PIN_2);            //RF_REVERSE

        SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOK);
        GPIOPinTypeADC(GPIO_PORTK_BASE, GPIO_PIN_0);            //TEMPERATURE
        GPIOPinTypeADC(GPIO_PORTK_BASE, GPIO_PIN_1);            //VDS
        GPIOPinTypeADC(GPIO_PORTK_BASE, GPIO_PIN_2);            //ID
        GPIOPinTypeADC(GPIO_PORTK_BASE, GPIO_PIN_3);            //VGS
        //ADCClockConfigSet(ADC0_BASE, ADC_CLOCK_SRC_PLL | ADC_CLOCK_RATE_FULL, 1);

        IntDisable(INT_ADC0SS0);
        ADCIntDisable(ADC0_BASE, 0);
        ADCSequenceDisable(ADC0_BASE, 0);

#if dma
        ADCSequenceConfigure(ADC0_BASE, 0, ADC_TRIGGER_ALWAYS, 0);
#else
        ADCSequenceConfigure(ADC0_BASE, 0, ADC_TRIGGER_PROCESSOR, 0);
#endif
        ADCSequenceStepConfigure(ADC0_BASE, 0, 0, ADC_CTL_CH0);
        ADCSequenceStepConfigure(ADC0_BASE, 0, 1, ADC_CTL_CH1);

        ADCSequenceStepConfigure(ADC0_BASE, 0, 2, ADC_CTL_CH16);
        ADCSequenceStepConfigure(ADC0_BASE, 0, 3, ADC_CTL_CH17);
        ADCSequenceStepConfigure(ADC0_BASE, 0, 4, ADC_CTL_CH18);
        ADCSequenceStepConfigure(ADC0_BASE, 0, 5, ADC_CTL_CH19|ADC_CTL_END);

        ADCHardwareOversampleConfigure(ADC0_BASE, 64);
        ADCSequenceDMAEnable(ADC0_BASE, 0);
        ADCSequenceEnable(ADC0_BASE, 0);

 }

 void digital_init()
   {


           SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOK);                     //PSFLT
           GPIOPinTypeGPIOInput(GPIO_PORTK_BASE, GPIO_PIN_4);
           GPIODirModeSet(GPIO_PORTK_BASE,GPIO_PIN_4,GPIO_DIR_MODE_IN);

          // GPIOPinTypeGPIOInput(GPIO_PORTK_BASE, GPIO_PIN_5);               //ARC
          // GPIODirModeSet(GPIO_PORTK_BASE,GPIO_PIN_5,GPIO_DIR_MODE_IN);

           GPIOPinTypeGPIOInput(GPIO_PORTK_BASE, GPIO_PIN_6);               //IDSLW
           GPIODirModeSet(GPIO_PORTK_BASE,GPIO_PIN_6,GPIO_DIR_MODE_IN);

           GPIOPinTypeGPIOInput(GPIO_PORTK_BASE, GPIO_PIN_7);               //TEMP
           GPIODirModeSet(GPIO_PORTK_BASE,GPIO_PIN_7,GPIO_DIR_MODE_IN);

           HWREG(GPIO_PORTD_BASE + GPIO_O_LOCK) = GPIO_LOCK_KEY;
           HWREG(GPIO_PORTD_BASE + GPIO_O_CR) = 0x80;

           SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOD);                     //FROM MAIN
           GPIOPinTypeGPIOInput(GPIO_PORTD_BASE, GPIO_PIN_7);
           GPIODirModeSet(GPIO_PORTD_BASE,GPIO_PIN_7,GPIO_DIR_MODE_IN);


           GPIOPinTypeGPIOOutput(GPIO_PORTD_BASE, GPIO_PIN_6);
           GPIOPadConfigSet(GPIO_PORTD_BASE,GPIO_PIN_6,GPIO_STRENGTH_10MA,GPIO_PIN_TYPE_STD_WPU );

           GPIODirModeSet(GPIO_PORTD_BASE,GPIO_PIN_6,GPIO_DIR_MODE_OUT);
           GPIOPinWrite(GPIO_PORTD_BASE, GPIO_PIN_6, 0x02);


           SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOM);             //INTERLOCK PIN
           GPIOPinTypeGPIOOutput(GPIO_PORTM_BASE, GPIO_PIN_1);
           GPIOPadConfigSet(GPIO_PORTM_BASE,GPIO_PIN_1,GPIO_STRENGTH_10MA,GPIO_PIN_TYPE_STD_WPU );
           GPIODirModeSet(GPIO_PORTM_BASE,GPIO_PIN_1,GPIO_DIR_MODE_OUT);
           GPIOPinWrite(GPIO_PORTM_BASE, GPIO_PIN_1, 0x02);

           SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOH);     //  FOR LED
           GPIOPinTypeGPIOOutput(GPIO_PORTH_BASE, GPIO_PIN_3);

           GPIOPinWrite(GPIO_PORTH_BASE, GPIO_PIN_3, 0x0);

  }




/*
 *  ======== tcpHandler ========
 *  Creates new Task to handle new TCP connections.
 */
Void tcpHandler(UArg arg0, UArg arg1)
{


    fdOpenSession(TaskSelf());

    lSocket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
    if (lSocket < 0) {
       // System_printf("tcpHandler: socket failed\n");
        Task_exit();
        return;
    }

    memset((char *)&sLocalAddr, 0, sizeof(sLocalAddr));
    sLocalAddr.sin_family = AF_INET;
    //sLocalAddr.sin_addr.s_addr = inet_addr("192.168.0.135");//htonl(INADDR_ANY);
    sLocalAddr.sin_addr.s_addr = inet_addr("192.168.1.135");//htonl(INADDR_ANY);
    sLocalAddr.sin_port = htons(arg0);


    while(connect(lSocket, (struct sockaddr *)&sLocalAddr, sizeof(sLocalAddr)) < 0)
    {
        SysCtlDelay(400000);
    }

   // System_flush();

    InitConsole();
    InitUDMA();


    while (true)
    {

#if dma
#else
       // GPIO_toggle(Board_LED0);
       ADCProcessorTrigger(ADC0_BASE, 0);
       // ADCSequenceDataGet(ADC0_BASE, 0, ADC_OUT_1);
       RF_count++;
       VDS_count++;
       ID_count++;
       TEMP_count++;

        if(uDMAChannelModeGet(UDMA_CHANNEL_ADC0|UDMA_PRI_SELECT) == 0)
             {
                 uDMAChannelTransferSet(UDMA_CHANNEL_ADC0 | UDMA_PRI_SELECT,UDMA_MODE_BASIC,(void *)(ADC0_BASE + ADC_O_SSFIFO0), ADC_OUT_1,6);
                 uDMAChannelEnable(UDMA_CHANNEL_ADC0);
                // uDMAChannelRequest(UDMA_CHANNEL_ADC0);
                 //counter++;
             }
                /*RF_FORWARD[flash_counter]   = ADC_OUT_1[1];
                RF_REVERSE[flash_counter]   = ADC_OUT_1[2];
                TEMPERATURE[flash_counter]  = ADC_OUT_1[3];
                VDS[flash_counter]          = ADC_OUT_1[4];
                ID[flash_counter]           = ADC_OUT_1[5];
                VGS[flash_counter]          = ADC_OUT_1[0];*/
#endif

        PSFLT=GPIOPinRead(GPIO_PORTK_BASE,GPIO_PIN_4);
        //ARC=GPIOPinRead(GPIO_PORTK_BASE,GPIO_PIN_5);
        IDSLW=GPIOPinRead(GPIO_PORTK_BASE,GPIO_PIN_6);
        TEMP=GPIOPinRead(GPIO_PORTK_BASE,GPIO_PIN_7);
        MAIN_IN=GPIOPinRead(GPIO_PORTD_BASE,GPIO_PIN_7);

        DIGI_IO = (MAIN_IN << 0)+ (TEMP << 1) + (IDSLW << 2) + (ARC << 3) + (PSFLT << 4) ;



//        RF_FORWARD= ADC_OUT_1[1];           //PE3
//        RF_REVERSE= ADC_OUT_1[2];           //PE2
//        TEMPERATURE=ADC_OUT_1[3];           //PK0
//        VDS        =ADC_OUT_1[4];           //PK1
//        ID         =ADC_OUT_1[5];           //PK2
//        VGS        =ADC_OUT_1[0];           //PK3
        if(DIGI_IO>0)
        {
            memmove(&DIGI_BUFF[0], &DIGI_BUFF[1], (SIZE_N - 1) * sizeof(DIGI_BUFF[0]));
            DIGI_BUFF[SIZE_N - 1] = DIGI_IO;
            LOCK =true;
            sprintf(mydata,"*D01$DGI$%d#",DIGI_IO);
            send(lSocket, (char *)mydata,sizeof(mydata), 0 );
        }
        if(VDS_count>250)
        {
            VDS_count=0;
            memmove(&VDS[0], &VDS[1], (SIZE_N - 1) * sizeof(VDS[0]));
            VDS[SIZE_N - 1] = ADC_OUT_1[4];
            memmove(&VGS[0], &VGS[1], (SIZE_N - 1) * sizeof(VGS[0]));
            VGS[SIZE_N - 1] = ADC_OUT_1[0];

            sprintf(mydata,"*D01$VDS$VGS$%lu,%lu#",ADC_OUT_1[4],ADC_OUT_1[0]);
            send(lSocket, (char *)mydata,sizeof(mydata), 0 );
        }
        if(ID_count>25)
        {
            ID_count=0;
            memmove(&ID[0], &ID[1], (SIZE_N - 1) * sizeof(ID[0]));
            ID[SIZE_N - 1] = ADC_OUT_1[5];
            sprintf(mydata,"*D01$ID$%lu#",ADC_OUT_1[5]);
            send(lSocket, (char *)mydata,sizeof(mydata), 0 );
        }
        if(TEMP_count>25000)
        {
            memmove(&TEMPERATURE[0], &TEMPERATURE[1], (SIZE_N - 1) * sizeof(TEMPERATURE[0]));
            TEMPERATURE[SIZE_N - 1] = ADC_OUT_1[3];
            TEMP_count=0;
            sprintf(mydata,"*D01$TMP$%lu#",ADC_OUT_1[3]);
            send(lSocket, (char *)mydata,sizeof(mydata), 0 );
        }


        if(RF_count>2)
                {
                    RF_count=0;
                    memmove(&RF_REVERSE[0], &RF_REVERSE[1], (SIZE_N - 1) * sizeof(RF_REVERSE[0]));
                    RF_REVERSE[SIZE_N - 1] = ADC_OUT_1[2];

                    memmove(&RF_FORWARD[0], &RF_FORWARD[1], (SIZE_N - 1) * sizeof(RF_FORWARD[0]));
                    RF_FORWARD[SIZE_N - 1] = ADC_OUT_1[1];


                    sprintf(mydata,"*D01$RFF$RFR$%lu,%lu#",ADC_OUT_1[1],ADC_OUT_1[2]);
                    send(lSocket, (char *)mydata,sizeof(mydata), 0 );
                }

        if (ADC_OUT_1[1] > 4102 || ADC_OUT_1[2] > 4102 || ADC_OUT_1[3] > 3026|| ADC_OUT_1[4] > 3791|| ADC_OUT_1[5] > 3351|| ADC_OUT_1[0] > 3103 ||ADC_OUT_1[4] < 3146|| ADC_OUT_1[5] < 3138|| ADC_OUT_1[0] < 2482 || DIGI_IO > 0)
              {
                 // GPIOPinWrite(GPIO_PORTM_BASE, GPIO_PIN_1, 0x02);
                  LOCK =true;
              }

        if(LOCK)
        {
            GPIO_toggle(Board_LED1);
            flash_counter++;
            GPIOPinWrite(GPIO_PORTM_BASE, GPIO_PIN_1, 0x02);
            uint32_t pui32Data[2],readdata[2];
            if(flash_counter>=500)
            {

                pui32Data[0] = 0x00000008;
                pui32Data[1] = 0x56789def;
                error = FlashProgram(pui32Data,(uint32_t )FLASH_BASE_ADDR, sizeof(pui32Data));
               // FlashProgram(RF_FORWARD, FLASH_BASE_ADDR, sizeof(RF_FORWARD));
                flash_counter=0;
                //readdata[0]=FLASH_BASE_ADDR[0];
                //readdata[1]=FLASH_BASE_ADDR[1];
               // while(1);
            }
        }


//        if(counter>10)
//               {
//
//
//            GPIOPinWrite(GPIO_PORTH_BASE, GPIO_PIN_3, 0x08);
//                   counter=0;
//                   sprintf(mydata,"*D01$%lu,%lu,%lu,%lu,%lu,%lu,%d,%lu#",ADC_OUT_1[1],ADC_OUT_1[2],ADC_OUT_1[3],ADC_OUT_1[4],ADC_OUT_1[5],ADC_OUT_1[0],DIGI_IO,dev_ID0);
//                   send(lSocket, (char *)mydata,sizeof(mydata), 0 );
//              }

    }
}

/*
 *  ======== main ========
 */
int main(void)
{
//    Task_Handle taskHandle;
//    Task_Params taskParams;
//    Error_Block eb;

    g_ui32SysClock = SysCtlClockFreqSet((SYSCTL_XTAL_25MHZ |SYSCTL_OSC_MAIN | SYSCTL_USE_PLL |SYSCTL_CFG_VCO_480), 120000000);

    /* Call board init functions */
    Board_initGeneral();
    digital_init();


    Board_initGPIO();
    Board_initEMAC();


    GPIO_setCallback(Board_BUTTON0, gpioButtonFxn0);
    /* Enable interrupts */
    GPIO_enableInt(Board_BUTTON0);


    // ui32Config = ADCClockConfigGet(ADC0_BASE, &ui32ClockDiv);


    /* Start BIOS */
    BIOS_start();

    return (0);
}