This thread has been locked.

If you have a related question, please click the "Ask a related question" button in the top right corner. The newly created question will be automatically linked to this question.

error: #20: identifier "GPIO_PA0_U0RX" is undefined

Other Parts Discussed in Thread: TM4C1233H6PM

I have the same problem and I have been beating my head against the wall. And nobody has responded to this? Either it is never EXPLICITLY explained anywhere or is documented in such tangental fashion as to be indedciferable by an average human. This error is pervasive enough that it should be expilictly spelled out! Sorry for the rant but this has been enormously frustrating.

 

Please someone help with this.

 

Thanks in advance,

 

Mike Mosley 

  • Include  "driverlib/gpio.h" file in your code. 

    #define GPIO_PA0_U0RX           0x00000001, you will see this line in that file. 

  • Mike Mosley said:
    indedciferable by an average human

    I guess the target audience is not just "average humans", but those humans with experience of (embedded) 'C' software development?

    The message itself is very clear and explicit - it tells you that the symbol "GPIO_PA0_U0RX" is  not defined.

    To find where it is defined, the simplest approach is to just do a text search through all the StellarisWare header files.

    Most software toolsets and programmer's editors have a 'find in files' feature to do this - if yours doesn't, that could be a strong suggestion that it's not really up to the job.

    There are also command-line utilities like grep, and GUI versions like grepwin and wingrep:

    http://code.google.com/p/grepwin/

    http://www.wingrep.com/

    You could even use the 'Search' facility of the Windows file explorer - but it doesn't present its results very helpfully for this particular purpose.

    An alternative approach is to find a working (example) project which does successfully use the symbol, and use your toolset's 'go to definition' feature to find the definition. Again, if your particular toolset doesn't have such a feature, that could be a strong suggestion that it's not really up to the job.

    The documentation for the GPIO API does tell you that the relevant header is driverlib/gpio.h - so, rather than a brute-force search of the entire source, you could do a more targetted search in just that file...

  • Andy Neil said:
    the relevant header is driverlib/gpio.h

    Uh-oh - perhaps "not!"   Both responding posters "were" correct - however newer versions of the driverlib have moved this define to pin_map.h!   Andy's methods - nicely detailed above - will find this define. 

    There is a - heretofore "unadmitted" - elephant in this room...  These ARM MCUs are spectacularly capable - yet extremely complex - and sad to say may not be the best choice for one without adequate, past embedded MCU design & "C" programming experience.  (there - the obvious has been - at last - stated!)  LMI/TI have clearly made "best in class" efforts to lighten & speed the new user's burden - yet pitfalls exist and impale the unwary.  (and sometimes too - we who have fought prior MCU wars...)

    Does a fast/easy "cure" exist?  Probably not - but evidence is overwhelming that those "new to topic" - developing "alone" - will have a hard, lengthy, likely inefficient battle.  And like you - become frustrated.  While we sympathize - you've launched your small craft into high seas - in the face of storm warnings.  (perhaps not fully investigated)

    Frustration, delay, inefficiency surely are the "by-product" of operating w/in a vacuum.  Alternatives are available - local universities, skilled consultants (andy), this forum - provided you clearly define your issue (as you appear to have done), and finding and/or creating a local group of "like minded."   Frustration - while understandable - highlights your need for a "deeper investigation" of how you "landed on ARM" - and how you "realistically" planned for this new journey.  Some have found the less complex TI MSP430 MCUs capable for task and much easier to grasp & master.  This enables you to be more productive while building the skills/background which will raise your likelihood of success with ARM...   Experience does count - I've tried here to lay a pathway thru this forest...   Good luck...

  • cb1- said:
    newer versions of the driverlib have moved this define to pin_map.h!


    Useful piece of information.

    My first project required the use of Stellaris's GPIO functionality and in built MAC/PHY. Literally had to break my head trying to find my way in lwip. Thanks to this forum's help and trying persistently, i managed. I must say though the driver library available makes application development quiet a breeze as long as one knows how to use it along with the proper tools.

    Now i am off to MSP430. All the best to those using Stellaris in future. It's a good line up.

  • Hmmm.... there does seem to be a certain feeling abroad that microcontroller development is "easy" - and anyone should be able to "just do it"

    While not particularly  "difficult", embedded microcontroller development is certainly not trivial! The required skills span a number of "traditional" disciplines:

    • It requires familiarity with computer architectures;
    • It requires familiarity with electronics;
    • It requires proficiency in programming/software development

    In addition to the resources already mentioned, there are many organisations that provide training in software development - with particular emphasis on embedded systems; eg:

    http://www.doulos.co.uk
    http://www.feabhas.co.uk/

    http://www.ganssle.com/
    http://www.netrino.com/

    Your distributor should be able to put you in touch with local providers - and may even have their own provision...

    Some more resources mentioned here: http://blog.antronics.co.uk/2011/08/08/

     

  • This information is golden, BUT- I'm actually having the same problem, despite the fact that I have both defined:

    #include "driverlib/gpio.h"

    #include "driverlib/pin_map.h"

    But still get these errors:

    #20 identifier "GPIO_PA0_U0RX" is undefined main.c /Stellaris Hello World line 125 C/C++ Problem

    #20 identifier "GPIO_PA1_U0TX" is undefined main.c /Stellaris Hello World line 126 C/C++ Problem

    Just to make sure, I copied the project settings for the compiler include and linker search path options for the project I copied them from in the stellarisware package (\StellarisWare\boards\ek-lm4f120xl\uart_echo), but no dice! Can someone please shed some light on this?

  • Reece:

    You mean like this?:

    "../headers/BMA180Ports.cpp", line 194: error #20: identifier "GPIO_PA0_U0RX" is undefined
    8 errors detected in the compilati...

    Properties --> CCS Build --> ARM Compiler --> Advanced Options --> Predefined symbols

    Add your Board like this in the pre-defined symbols...

    PART_LM4F120H5QR

    That should do the last fix. For the current problem.

    I strongly suggest that you work through the tutorials for your board.

    The other guys are kidding -- anyone with junior high should be able to take on embedded programming... almost no knowledge is required up front.

  • Thanks Dave!! It's compiling now. I also had to add "TARGET_IS_BLIZZARD_RA1" and "ccs="ccs"" (I have no idea what those do!).

    I completely agree! I actually started in highschool ;). I'm a bit sold to TI ARM now though; I've just gotten so much free TI goodies tools through my University that the brand has stuck I guess. 

    I'll go through the tutorials too. Thanks again!

  • This was enormously helpful! Thanks for posting this!

     

    Mike Mosley

  • Hi,

    I followed your advice and added the symbol in the following way. 

    "${PART_LM4F120H5QR}"

    However, I am still getting the following error:

    error: option --define is missing its parameter 'NAME[=value]'

    Any help greatly appreciated.

    Thank you

    Damian

  • Hi,

    The parameter to be added has not the right syntax - instead "${PART_LM4F120H5QR}" should be simply PART_LM4F120H5QR - no braces, no $, no".

    As for error: message - search in console where it is generated - either for a file compilation (and then which one) either at the linker level - and in this case review all switches/options marked --define... to find out which one is not complete. 

    If all these fail, review the documentation - try to do(import) step by step a TI ready-made project - and see there all compiler settings.

    Petrei

  • Petrei,

     

    Thank you for the information. However, I still have errors. Do you know by any chance of uart_echo that is working and compiles without probelms?

     

    Thanks

    Damian

  • Hi,

    What are these errors now? can you show all? let's try to take it from the beginning - the program surely works.

    Petrei 

  • Petrei,

    I have the following warnings/errors.

    1. Any function that starts with ROM_ gives me the following warning:

    <a href="file:/C:/ti/ccsv5/tools/compiler/dmed/HTML/225.html">#225-D</a>  function declared implicitly


    2. These two function calls:

    GPIOPinConfigure(GPIO_PA0_U1RX);
    GPIOPinConfigure(GPIO_PA1_U1TX);

    give me the following errors:

    #20 identifier "GPIO_PA0_U1RX" is undefined

    3. And the summary from the build is as follows:

    **** Build of configuration Debug for project Echo1 ****

    "C:\\ti\\ccsv5\\utils\\bin\\gmake" -k all
    'Building file: ../main.c'
    'Invoking: ARM Compiler'
    "C:/ti/ccsv5/tools/compiler/arm_5.0.4/bin/armcl" -mv7M4 --code_state=16 --float_support=FPv4SPD16 --abi=eabi -me -g --include_path="C:/ti/ccsv5/tools/compiler/arm_5.0.4/include" --include_path="C:/StellarisWare" --define=PART_LM4F120H5QR --diag_warning=225 --display_error_number --diag_wrap=off --preproc_with_compile --preproc_dependency="main.pp" "../main.c"
    "../main.c", line 48: warning #225-D: function declared implicitly
    "../main.c", line 53: warning #225-D: function declared implicitly
    "../main.c", line 57: warning #225-D: function declared implicitly
    "../main.c", line 62: warning #225-D: function declared implicitly
    "../main.c", line 63: warning #225-D: function declared implicitly
    "../main.c", line 98: warning #225-D: function declared implicitly
    "../main.c", line 115: warning #225-D: function declared implicitly
    "../main.c", line 116: warning #225-D: function declared implicitly
    "../main.c", line 121: warning #225-D: function declared implicitly
    "../main.c", line 127: warning #225-D: function declared implicitly
    "../main.c", line 132: warning #225-D: function declared implicitly
    "../main.c", line 143: warning #225-D: function declared implicitly
    "../main.c", line 148: error #20: identifier "GPIO_PA0_U1RX" is undefined
    "../main.c", line 149: error #20: identifier "GPIO_PA1_U1TX" is undefined
    "../main.c", line 150: warning #225-D: function declared implicitly
    "../main.c", line 155: warning #225-D: function declared implicitly
    "../main.c", line 155: warning #225-D: function declared implicitly
    "../main.c", line 162: warning #225-D: function declared implicitly
    "../main.c", line 163: warning #225-D: function declared implicitly
    2 errors detected in the compilation of "../main.c".

    >> Compilation failure
    gmake: *** [main.obj] Error 1
    gmake: Target `all' not remade because of errors.

    **** Build Finished ****

    *************************************

    Any help greatly appreciated.

    Damian




  • Hello Damian,

    I suppose that you are using the LM4F120H5QR. The LM4F family are re-branded to TM4C family, and LM4F120H5QR has been renamed to TM4C1233H6PM. Therefore you can try PART_TM4C1233H6PM in the pre-defined field. For more information about part number, please refer to this document. Thank you.

    Regards,

    Jo

  • Jo,

    Thank you for the info but it does not work. I am getting the same set of warnings/errors. I am 100% that it some environment/variable problem that I have but I don't know which one.

    Thank you

    Damian

  • Hello Damian,

    Could you provide the pre-defined symbols you've written? The first problem, ROM_, needs you include driverlib/rom.h . Besides, a pre-defined symbol starts with TARGET_IS_XXXXXX_XX, depends on the chip you use.

    Regards,

    Jo

  • Jo,

    I have the driverlib/rom.h defined in my code. For the pre-defined symbol I have entered this: PART_TM4C1233H6PM. Should I enter TARGET_IS_PART_TM4C1233H6PM instead? Also I am using Stellaris LM4F120 LaunchPad board. So maybe I should enter something different altogether.

    Here is my code.

    #include "inc/hw_ints.h"
    #include "inc/hw_memmap.h"
    #include "inc/hw_types.h"
    #include "driverlib/debug.h"
    #include "driverlib/fpu.h"
    #include "driverlib/gpio.h"
    #include "driverlib/interrupt.h"
    #include "driverlib/pin_map.h"
    #include "driverlib/rom.h"
    #include "driverlib/sysctl.h"
    #include "driverlib/uart.h"
    #include "driverlib/pin_map.h"
     
     
    //*****************************************************************************
    //
    //! \addtogroup example_list//! <h1>UART Echo (uart_echo)</h1>A
    //!
    //! This example application utilizes the UART to echo text.  The first UART
    //! (connected to the USB debug virtual serial port on the evaluation board)
    //! will be configured in 115,200 baud, 8-n-1 mode.  All characters received on
    //! the UART are transmitted back to the UART.
    //
    //*****************************************************************************
    //*****************************************************************************//
    // The error routine that is called if the driver library encounters an error.//
    //*****************************************************************************
    #ifdef DEBUG
    void
    __error__(char *pcFilename, unsigned long ulLine)
    {
    }
    #endif
     
     
    //*****************************************************************************
    //
    // The UART interrupt handler.
    //
    //*****************************************************************************
    void
    UARTIntHandler(void)
    {
            unsigned long ulStatus;
            //
            // Get the interrrupt status.
            //
            ulStatus = ROM_UARTIntStatus(UART0_BASE, true);
     
            //
            // Clear the asserted interrupts.
            //
            ROM_UARTIntClear(UART0_BASE, ulStatus);
            //
            // Loop while there are characters in the receive FIFO.
            //
            while(ROM_UARTCharsAvail(UART0_BASE))
            {
                    //
                    // Read the next character from the UART and write it back to the UART.
                    //
                    ROM_UARTCharPutNonBlocking(UART0_BASE,
                                    ROM_UARTCharGetNonBlocking(UART0_BASE));
     
                    //
                    // Blink the LED to show a character transfer is occuring.
                    //
                    GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_2, GPIO_PIN_2);
     
                    //
                    // Delay for 1 millisecond.  Each SysCtlDelay is about 3 clocks.
                    //
                    SysCtlDelay(SysCtlClockGet() / (1000 * 3));
                    //
                    // Turn off the LED
                    //
                    GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_2, 0);
     
            }
    }
     
    //*****************************************************************************
    //
    // Send a string to the UART.
    //
    //*****************************************************************************
    void
    UARTSend(const unsigned char *pucBuffer, unsigned long ulCount)
    {
            //
            // Loop while there are more characters to send.
            //
            while(ulCount--)
            {
                    //
                    // Write the next character to the UART.
                    //
                    ROM_UARTCharPutNonBlocking(UART0_BASE, *pucBuffer++);
            }
    }
     
    //*****************************************************************************
    //
    // This example demonstrates how to send a string of data to the UART.
    //
    //*****************************************************************************
    int
    main(void){
            //
            // Enable lazy stacking for interrupt handlers.  This allows floating-point
            // instructions to be used within interrupt handlers, but at the expense of
            // extra stack usage.
            //
           
            ROM_FPUEnable();
            ROM_FPULazyStackingEnable();
            //
            // Set the clocking to run directly from the crystal.
            //
           
            ROM_SysCtlClockSet(SYSCTL_SYSDIV_1 | SYSCTL_USE_OSC | SYSCTL_OSC_MAIN |
                                               SYSCTL_XTAL_16MHZ);
            //
            // Enable the GPIO port that is used for the on-board LED.
            //
           
            ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF);
            //
            // Enable the GPIO pins for the LED (PF2).
            //
           
            ROM_GPIOPinTypeGPIOOutput(GPIO_PORTF_BASE, GPIO_PIN_2);
            //
            // Enable the peripherals used by this example.
            //
     
            ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_UART0);
            ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA);
            //
            // Enable processor interrupts.
            //
     
            ROM_IntMasterEnable();
            //
            // Set GPIO A0 and A1 as UART pins.
            //
     
            GPIOPinConfigure(GPIO_PA0_U1RX);
            GPIOPinConfigure(GPIO_PA1_U1TX);
            ROM_GPIOPinTypeUART(GPIO_PORTA_BASE, GPIO_PIN_0 | GPIO_PIN_1);
            //
            // Configure the UART for 115,200, 8-N-1 operation.
            //
     
            ROM_UARTConfigSetExpClk(UART0_BASE, ROM_SysCtlClockGet(), 115200,
                            (UART_CONFIG_WLEN_8 | UART_CONFIG_STOP_ONE |
                                            UART_CONFIG_PAR_NONE));
            //
            // Enable the UART interrupt.
            //
     
            ROM_IntEnable(INT_UART0);
            ROM_UARTIntEnable(UART0_BASE, UART_INT_RX | UART_INT_RT);
            //
            // Prompt for text to be entered.
            //
     
            UARTSend((unsigned char *)"\033[2JEnter text: ", 16);
            //
            // Loop forever echoing data through the UART.
            //
           
            while(1)
            {
     
            }
    }

    Thanks

    DAmian

  • Hello Damian,

    You need these two: TARGET_IS_BLIZZARD_RA2 and  PART_TM4C1233H6PM pre-defined.

    The former one can help you correctly use functions which reside in ROM ; the later one is telling it the correct pin map. that's why you need these info. predefined.

    Hope these can help you!

    Regards,

    Jo

  • Jo,

    Wow, the first one took care of all of my warnings!!!

    The second one did not help however... I still have two errors:

    "../main.c", line 148: error #20: identifier "GPIO_PA0_U1RX" is undefined
    "../main.c", line 149: error #20: identifier "GPIO_PA1_U1TX" is undefined
    2 errors detected in the compilation of "../main.c".

    However, thank you very much, this was a powerful advice!!!!!!

    Damian

  • Hello Damian,

    Ok, I found the problem. GPIO Port A pin 0 and pin 1 are for uart 0, you have to use GPIO_PA0_U0RX and GPIO_PA1_U0TX.

    That should be ok now.

    Regards,

    Jo

  • Jo,

    I made a change but I still have these errors:

    GPIOPinConfigure(GPIO_PA0_U0RX);
    GPIOPinConfigure(GPIO_PA1_U0TX);

    **** Build of configuration Debug for project Echo1 ****

    "C:\\ti\\ccsv5\\utils\\bin\\gmake" -k all
    'Building file: ../main.c'
    'Invoking: ARM Compiler'
    "C:/ti/ccsv5/tools/compiler/arm_5.0.4/bin/armcl" -mv7M4 --code_state=16 --float_support=FPv4SPD16 --abi=eabi -me -g --include_path="C:/ti/ccsv5/tools/compiler/arm_5.0.4/include" --include_path="C:/StellarisWare" --define=PART_TM4C1233H6PM --define=TARGET_IS_BLIZZARD_RA2 --diag_warning=225 --display_error_number --diag_wrap=off --preproc_with_compile --preproc_dependency="main.pp" "../main.c"
    "../main.c", line 148: error #20: identifier "GPIO_PA0_U0RX" is undefined
    "../main.c", line 149: error #20: identifier "GPIO_PA1_U0TX" is undefined

    >> Compilation failure
    2 errors detected in the compilation of "../main.c".
    gmake: *** [main.obj] Error 1
    gmake: Target `all' not remade because of errors.

    **** Build Finished ****

  • Hello Damian,
    I checked StellarisWare, you have to use PART_LM4F120H5QR instead of PART_TM4C1233H6PM, for now. And here is the reference code for you:

     

    #include "inc/hw_ints.h"
    #include "inc/hw_memmap.h"
    #include "inc/hw_types.h"
    #include "driverlib/debug.h"
    #include "driverlib/fpu.h"
    #include "driverlib/gpio.h"
    #include "driverlib/interrupt.h"
    #include "driverlib/pin_map.h"
    #include "driverlib/rom.h"
    #include "driverlib/sysctl.h"
    #include "driverlib/uart.h"
    #include "driverlib/pin_map.h"

      

    //*****************************************************************************
    //
    //! \addtogroup example_list//! <h1>UART Echo (uart_echo)</h1>A
    //!
    //! This example application utilizes the UART to echo text.  The first UART
    //! (connected to the USB debug virtual serial port on the evaluation board)
    //! will be configured in 115,200 baud, 8-n-1 mode.  All characters received on
    //! the UART are transmitted back to the UART.
    //
    //*****************************************************************************
    //*****************************************************************************//
    // The error routine that is called if the driver library encounters an error.//
    //*****************************************************************************
    #ifdef DEBUG
    void
    __error__(char *pcFilename, unsigned long ulLine)
    {
    }
    #endif

      

    //*****************************************************************************
    //
    // The UART interrupt handler.
    //
    //*****************************************************************************
    void
    UARTIntHandler(void)
    {
            unsigned long ulStatus;
            //
            // Get the interrrupt status.
            //
            ulStatus = ROM_UARTIntStatus(UART0_BASE, true);

     

            //
            // Clear the asserted interrupts.
            //
            ROM_UARTIntClear(UART0_BASE, ulStatus);
            //
            // Loop while there are characters in the receive FIFO.
            //
            while(ROM_UARTCharsAvail(UART0_BASE))
            {
                    //
                    // Read the next character from the UART and write it back to the UART.
                    //
                    ROM_UARTCharPutNonBlocking(UART0_BASE,
                                    ROM_UARTCharGetNonBlocking(UART0_BASE));

     

                    //
                    // Blink the LED to show a character transfer is occuring.
                    //
                    ROM_GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_2, GPIO_PIN_2);

     

                    //
                    // Delay for 1 millisecond.  Each SysCtlDelay is about 3 clocks.
                    //
                    ROM_SysCtlDelay(ROM_SysCtlClockGet() / (1000 * 3));
                    //
                    // Turn off the LED
                    //
                    ROM_GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_2, 0);

     

            }
    }

     

    //*****************************************************************************
    //
    // Send a string to the UART.
    //
    //*****************************************************************************
    void
    UARTSend(const unsigned char *pucBuffer, unsigned long ulCount)
    {
            //
            // Loop while there are more characters to send.
            //
            while(ulCount--)
            {
                    //
                    // Write the next character to the UART.
                    //
                    ROM_UARTCharPutNonBlocking(UART0_BASE, *pucBuffer++);
            }
    }

     

    //*****************************************************************************
    //
    // This example demonstrates how to send a string of data to the UART.
    //
    //*****************************************************************************
    int
    main(void){
            //
            // Enable lazy stacking for interrupt handlers.  This allows floating-point
            // instructions to be used within interrupt handlers, but at the expense of
            // extra stack usage.
            //

     

            ROM_FPUEnable();
            ROM_FPULazyStackingEnable();
            //
            // Set the clocking to run directly from the crystal.
            //

     

            ROM_SysCtlClockSet(SYSCTL_SYSDIV_1 | SYSCTL_USE_OSC | SYSCTL_OSC_MAIN |
                                               SYSCTL_XTAL_16MHZ);
            //
            // Enable the GPIO port that is used for the on-board LED.
            //

     

            ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF);
            //
            // Enable the GPIO pins for the LED (PF2).
            //

     

            ROM_GPIOPinTypeGPIOOutput(GPIO_PORTF_BASE, GPIO_PIN_2);
            //
            // Enable the peripherals used by this example.
            //

     

            ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_UART0);
            ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA);
            //
            // Enable processor interrupts.
            //

     

            ROM_IntMasterEnable();
            //
            // Set GPIO A0 and A1 as UART pins.
            //

     

            ROM_GPIOPinConfigure(GPIO_PA0_U0RX);
            ROM_GPIOPinConfigure(GPIO_PA1_U0TX);
            ROM_GPIOPinTypeUART(GPIO_PORTA_BASE, GPIO_PIN_0 | GPIO_PIN_1);
            //
            // Configure the UART for 115,200, 8-N-1 operation.
            //

     

            ROM_UARTConfigSetExpClk(UART0_BASE, ROM_SysCtlClockGet(), 115200,
                            (UART_CONFIG_WLEN_8 | UART_CONFIG_STOP_ONE |
                                            UART_CONFIG_PAR_NONE));
            //
            // Enable the UART interrupt.
            //

     

            ROM_IntEnable(INT_UART0);
            ROM_UARTIntEnable(UART0_BASE, UART_INT_RX | UART_INT_RT);
            //
            // Prompt for text to be entered.
            //

     

            UARTSend((unsigned char *)"\033[2JEnter text: ", 16);
            //
            // Loop forever echoing data through the UART.
            //

     

            while(1)
            {

     

            }
    }
  • Hi Jo,

    It works perfect. Thank you very much for the advice. Is there any good reference manual/link where I can learn what symbols should be defined and when. The first symbol I would have never guessed the second maybe.

    Again thank you for all your help.

    Damian

  • Hello Damian,

    Please refer to this TI wiki webpage, you can find workbook at near the middle of the wiki page, and example code, of course. I recommend you briefly go through this workshop, it mentioned the predefined stuff in Lab 4 & 5. 

    Regards,

    Jo

  • Thank u soo much....I was stuck due to this problem.it was really helpful.

    Ganesh 

  • Dave Robinson ,you saved so much of my time mentioning this . i almost forgot where did i go wrong for hours . thank you