• State Not Answered
  • Locked Locked
  • Replies 8 replies
  • Subscribers 21 subscribers
  • Views 1779 views
  • Users 0 members are here
2025 survey

We are running a survey to help us improve the experience for all of our members. If you see the survey appear, please take the time to tell us about your experience if you can.

Options
Related
How was your experience today?
This discussion has been locked.
You can no longer post new replies to this discussion. If you have a question you can start a new discussion

Optimizing problems (volatile hardware register)

Sven Petersen

I have had a rather ugly problem caused due to the optimization.

I am reading data from a fifo. The read port is at address 0x8200 (read only access). It also has a read reset port. Its address is also 0x8200 (both xdata) (write onle access).

When I declare the varables for accessing the fifo like this:

xdata uchar fifo_data     _at_ 0x8200; xdata uchar fifo_rres     _at_ 0x8200;
It will result in a linker warning memory overlap. Thus I have decided to do it like this:
xdata uchar fifo_data     _at_ 0x8200;
#define fifo_rres fifo_data

In a routine I have programmed this code:
  fifo_rres = 0xff;                // reset fifo read
  jpg_adr = 1;                     // set jpg file address to the next address to be read
  fbuf_start = 0;                  // set buffer start pointer to zero
  fbuf_in = 1;                     // set buffer input pointer to next free byte in buffer
  fbuf_pos = 0;                    // set buffer read pointer to zero
  fbuf_startadr = 0;               // set buffer startadress to zero
  fbuf[0] = fifo_data;             // read first byte from jpg file

The result was, that fbuf[0] was always 0xff. Then I have read the disassembly and found that when I want to set fbuf[0], I don't access the fifo read register, but it is written with 0xff.

I think, this is matter of the compiler optimization. The compiler thinks, that when I write 0xff into some address and read it some lines later, it will still be 0xff.

How can I tell the compiler, that it is not the same? I didn't find anything in my C51 manual about that topic. Maybe I just didn't find it.

  • 0 in reply to erik malund

    To flesh out a bit;

    volatile xdata uchar fifo_data     _at_ 0x8200;
#define fifo_rres fifo_data
    The keyword 'volatile' tells the compiler to not optimize accesses to a variable, assuming it can be changed by some other, unknown, means. It should be used anytime a variable is changed by a background function, hardware or in a different thread in multi-threaded systems.
    Best luck

  • 0 

    xdata uchar fifo_data     _at_ 0x8200; 
xdata uchar fifo_rres     _at_ 0x8200;

    As far as the 'C' language is concerned, these are two separate definitions creating 2 distinct variables - so you will obviously get the Linker warning!

    An alternative might be to use a Union - not sure how that might affect the efficiency of access, though?

    Other options would be to do it in Assembler, or leave it to the Linker.

  • 0 in reply to Andrew Neil

    what about

    xdata uchar fifo_data     _at_ 0x8200; 
#define fifo_rres  fifo_data
    Erik

  • 0 in reply to erik malund

    Hi there,

    thanks for the quick help. I had heard something about "volatile" before, but I couldn't find anything about it in my Keil books. After I got the reply, I have found it as a footnote in the Kernighan&Ritchie.

    So what I have done is:

    #define FIFO_READ_ADR 0x8200
[...]
xdata volatile uchar fifo_data _at_ FIFO_READ_ADR;  // fifo data register (read only)
#define fifo_rres fifo_data

    And voila (or should I say volatile), it works.

  • 0

    Just a suggestion:

    File fifoin.c:

    xdata uchar fifo_data  _at_ 0x8200;

    File fifoin.h:
    extern xdata uchar fifo_data;
#define fifo_rres  XBYTE[0x8200]

    File the_file_i_use_the_fifo_stuff.c:
    #include <absacc.h>
#include "fifoin.h"
/* now fifo_data and fifo_rres are */
/*competely different to the Compiler*/

    I know, this is too complicated and -yuck- it's ugly
    style, but as a starting point for further ideas it may do.

    Good Luck

    Norbert

  • 0 in reply to Norbert Paul

    I'd like to cancel my prevoius message.

  • 0 in reply to Norbert Paul

    If you're hell-bent on having 2 variables at the same address, there is an easy way to handle it.

    1. In your C code, create external definitions. For example:

    extern unsigned char xdata var1;
extern unsigned char xdata var2;

    2. Create an assembler module that appears as follows:

    xseg	at	0x8000

public var1
public var2

var1:
var2:	DS	1

end

    This declares var1 and var2 at XDATA address 0x8000. Each is 1 byte long. If these variables are 16-bit vars, change the DS 1 to DS 2.

    Jon