External RAM memory tester program

How do you know that the pointer is null? The pointer points at 0x00000 adress. How to check it?

What I want to do is to point, for example, at first adress of my external RAM, but I don't know how to do it.

I simply use the variable "j"to store the value that 'memTestDataBus' function returns and afterwards to send it through ASC0.

How do you know that the pointer is null? The pointer points at 0x00000 adress. How to check it?

What I want to do is to point, for example, at first adress of my external RAM, but I don't know how to do it.

I simply use the variable "j"to store the value that 'memTestDataBus' function returns and afterwards to send it through ASC0.

ASC0_TBUF = memTestDataBus(pointer);

Will send the result without the use of a variable.

The datasheet (and possibly your external connections) should tell you where the memory is and how large it is - if your project doesn't know where the memory is, the compiler + linker will not be able to produce a project that makes use of the memory as expected.

But I want you to once more think about one important issue: If you let the memtest function test a memory cell that is used for stack or for storing any of your variables, you will not get the expected result. The function call may not even return.

John,

Don't try this stuff at home, or in your product! :-)

ASC0_TBUF = memTestDataBus(&memTestDataBus);

Here is my Memory mapping:
img160.imagevenue.com/img.php

And here the indicated adresses y my project
img133.imagevenue.com/img.php

John,

How do you know that the pointer is null? The pointer points at 0x00000 adress. How to check it?

In order to verify that a pointer does not point at a null address, such a test can be used:

if (pointer)
{
   // this code is executed if pointer is not null
}
else
{
   // this code is executed if pointer is null
}

Note however that Per comments are very much in place: even if a pointer is not null, is does not mean that it points to an address on which you can run your test. running the test might destroy data/code, just like demonstrated in my previous post.

#include <XC164.h>
#include <intrins.h>
#define ASC0_TINT    0x2A

typedef unsigned char U8;                       /* Set the data bus width to 8 bits. */
U8      memTestDataBus(volatile U8 * address);


volatile U8   *pointer;
sbit    MY_OUT = P1L^0;

void    main    (void)
{
        DP1L           =  0x0001;      // load direction register
        pointer = 0x400000;                        // the pointer points at 0x400000 adress

        if (pointer)
        {
                MY_OUT = 1;              // this code is executed if pointer is not null
        }
        while (1)
        {
                 ;
        }
}

Tamir, with this code, MY_OUT is to 5V, therefore,as you can see, the pointer isn't null

What else can I do?
Thanks ;-)

what is the problem, again?

pointer = 0x400000;

indeed points 'pointer' to a non-null address.

pointer = 0x400000;   // the pointer points at 0x400000 adress

if (memTestDataBus(pointer) == 0)       MY_OUT = 1; // if the result of the test is ok toggle MY_OUT to 5V

Is it well done the instruction to check the databus test?

looks ok as long as no component of your program is mapped to 0x400000.

Soon I will do the test.

Tamir, "MY_OUT" has been set. => The data test its ok! :-D
Now, I am going to do the adresses test.
Thanks for your help.
I write here the used program if someone need it:

#include <XC164.h>
#include <intrins.h>

typedef unsigned char U8;               // Set the data bus width to 8 bits.
U8      memTestDataBus(volatile U8 * address);

volatile U8   *pointer;
sbit    MY_OUT = P1L^0;

void    main    (void)
{
        DP1L           =  0x0001;  // load direction register
        pointer = 0x400000;                // the pointer points at 0x400000 adress

        if (memTestDataBus(pointer) == 0)       MY_OUT = 1; // if the result of the test is ok toggle MY_OUT to 5V

        while (1)
        {
                 ;
        }
}
///////////////////////////////////////////////////////////////////////
U8      memTestDataBus(volatile U8 * address)
{
        U8 pattern;

        for (pattern = 1; pattern != 0; pattern <<= 1)
        {
                //Write the test pattern.
                *address = pattern;

                //Read it back (immediately is okay for this test).
                if (*address != pattern)
                {
                        return (pattern);
                }
        }
                return (0);
} /* memTestDataBus() */
/////////////////////////////////////////////////////////////////////////

But are you aware that the memTestDataBus() only tests if there exists working memory at one specific little byte. It does not test all cells of the memory. An external loop is needed to step "pointer" to all RAM addresses and test them one-by-one. But once more: the test is destructive, so if it tests a RAM cell that contains critical data, your program will crash.

Another interesting thing is that memory constructs that doesn't multiplex address and data can pass such a memory test since a write followed by a read may pick up the old signal states. Capacitances on the signals will make it possible to write out in the air, and then read back the same value. In such cases, it is good to write a test pattern to one address, and a dummy pattern to another address and then read back the test pattern from the original address. If reading air, you will get the dummy pattern instead of the test pattern.

John,
Have you read Per's comments AND the article whose address that I posted above? obviously you didn't, because both address a critical mistake in your code...

Per, as it is written in Tamirs article toverify if the program writes well or not, is only needed any adress and probe that all posible datas are well written.
Although, the program is destructive, at first the memory doesn't contain any critical data.

Ups, I didn't read the last post of Tamir. It seems that I donÂ't understand well the article.