10 years, 8 months ago.

Hi Reed,

Did you try to use a union? e.g.:

struct t_any_data {

int nVal1; int nVal2; char szText[10];

};

union t_byte_data {

struct t_any_data Data; char Bytes[sizeof(t_any_data)];

} Frame;

Frame.Data.nVal1 = 5; Access nVal1, stores 5 into Frame.Bytes[0] = 7; Access nVal1, Byte 0, overwrites with 7

Now you can swap between single byte/char access and formated data access.

With greetings

Joachim

10 years, 8 months ago.

Hi Reed, what you are looking for is serialization of the objects, where the struct is in fact a C++ object. This link may help you: http://www.functionx.com/cpp/articles/serialization.htm

Hope this helps, Henrik

10 years, 8 months ago.

Hello Reed, in your above example the FRamIO::WriteByte and FRamIO::ReadByte methods calculate the number of bytes to write/read incorrectly. You have the following line in both of these functions:

    int len = (int)sizeof(data);

The sizeof(data) will always be 4 since that is the size of a pointer on this 32-bit architecture. That means only the first 4 bytes of your structure are actually being read/written from/to FLASH.

You should make len a parameter of those methods and pass it in from the caller which actually knows the size of the data structures you are trying to write/read.

bool FRamIO::WriteByte(int address, const char* data, size_t len) {
    fram.start();
    fram.write(ramAddr);
    fram.write(address >> 8);
    fram.write(address & 0xFF);
    for (size_t i=0; i<len; i++) {
        fram.write(data[i]);
    }
    fram.stop();
    return true;
}
 
bool FRamIO::ReadByte(int address, char* data, size_t len) {
    fram.start();
    fram.write(ramAddr);
    fram.write(address >> 8);
    fram.write(address & 0xFF);
    fram.start();
    fram.write(ramAddr | 0x01);
    for (size_t i=0; i<len; i++) {
        int s = 1;
        if (i == len - 1) {s = 0;}
        data[i] = fram.read(s);
    }
    fram.stop();
    return true;
} 

...


void Interpreter::GetProdItem(int index, ProductionItem* item) {
    fRam.ReadByte(addProdItem0 + (prodItemSize * index), (char*)item, sizeof(*item));
}
 
void Interpreter::SetProdItem(int index, ProductionItem* item) {
    fRam.WriteByte(addProdItem0 + (prodItemSize * index), (const char*)item, sizeof(*item));
}

10 years, 8 months ago.

Thanks for the help thus far everyone, but I'm still not getting it...

@Adam: Ah of course... at one point I was trying to pass an actual character array and then the count was accurate, when I changed to the pointer I failed to consider the change to the sizeof result. So I've corrected those two routines.

@Erik: This is what I wanted to do to begin with, and I've tried it again but I'm still not getting proper results. It probably has to do with passing the value between methods... but I don't know where I've gone wrong.

Here are the Read/Write methods after Adam's correction:

bool FRamIO::WriteByte(int address, char* data, size_t len) {
    fram.start();
    fram.write(ramAddr);
    fram.write(address >> 8);
    fram.write(address & 0xFF);
    for (int i=0; i<len; i++) {
        fram.write(data[i]);
    }
    fram.stop();
    return true;
}

bool FRamIO::ReadByte(int address, char* data, size_t len) {
    fram.start();
    fram.write(ramAddr);
    fram.write(address >> 8);
    fram.write(address & 0xFF);
    fram.start();
    fram.write(ramAddr | 0x01);
    for (int i=0; i<len; i++) {
        int s = 1;
        if (i == len - 1) {s = 0;}
        data[i] = fram.read(s);
    }
    fram.stop();
    return true;
}     

The Get/Set methods on Interpreter now look like:

void Interpreter::GetProdItem(int index, ProductionItem* item) {
    char* data = new char[64];
    fRam.ReadByte(addProdItem0 + (prodItemSize * index), data, 64);
    item = (ProductionItem*) data;
}

void Interpreter::SetProdItem(int index, ProductionItem item) {
    char* data; 
    data = (char*) &item;
    fRam.WriteByte(addProdItem0 + (prodItemSize * index), data, 64);
}

And for the test commands I've got:

    else if(command == "testitemsave") {
        int idx;
        sscanf(params[0].data(), "%i", &idx);
        ProductionItem item;
        strcpy(item.Number, "12SWS256");
        item.Cavities = 12;
        item.Required = 5000;
        item.Count = 0;
        SetProdItem(idx, item);
        result = "Attempted to save item...";
    }
    else if(command == "testitemload") {
        int idx;
        sscanf(params[0].data(), "%i", &idx);
        ProductionItem item;
        GetProdItem(idx, &item);
        char msg[128];
        sprintf(msg, "Item: %s, Cav: %i, Req: %i, Cnt: %i", item.Number, item.Cavities, item.Required, item.Count);
        result = msg;
    }

This all compiles with a warning of: "Parameter "item" was set but never used" pointing to the line:

void Interpreter::GetProdItem(int index, ProductionItem* item) {

Again I've experimented with variations of declaring values and passing pointers along with declaring pointers and passing them directly, but I mostly just get empty values in the structure instance other than the last integer which is always the same value (making me think I'm still writing/reading a pointer instead of the value it points to).

I apologize for the convolution of the code in question but I have often found that I can make a simple example work just fine and the problems only occur when I try to structure my code into a domain model and start passing parameters between methods... that's always when things get wonky on me so that's why I wanted to keep the context of the chain of method calls that I need to use.

Thanks again to everyone trying to help.