AVR Freaks

Thanks, but it's not working for me yet.  If I initialize with:

struct Frame * Animations[3] = {loop1, loop2, loop3};   // Frame is the name of the struct, loopn is the name of the array of Frames in flash

I get a compiler error:  invalid initialization type; found `pointer to __flash struct Frame' expected `pointer to struct Frame'|

If I initialize with:

 struct Frame * flash Animations[3] = {loop1, loop2, loop3};

I get the same error.

If I initialize with:

struct Frame * __flash Animations[3] = {loop1, loop2, loop3};

Same error.  I'm using Jumpstart C (formerly ICCAVR) which supports __flash.  That's how I declare the loopn arrays.

Here are the declarations as they appear in the code (in this order):

struct Frame {
    unsigned char digit;    // Digit:  0 = 1 minutes, 1 = 10 minutes, etc.
    unsigned char seg;      // Segment to turn on:  a - g
    unsigned char onoff;    // 0 = segment off, 1 = segment on
    unsigned char dur;      // Duration in msec. to maintain segment state
};

__flash struct Frame loop1[] = {
{0, 'a', 1, 50}, {0, 'a', 0, 50}, {0, 'b', 1, 50}, {0, 'b', 0, 50}, {0, 'c', 1, 50}, {0, 'c', 0, 50}, {0, 'd', 1, 50}, {0, 'd', 0, 50},
{1, 'd', 1, 50}, {1, 'd', 0, 50}, {2, 'd', 1, 50}, {2, 'd', 0, 50}, {3, 'd', 1, 50}, {3, 'd', 0, 50}, {3, 'e', 1, 50}, {3, 'e', 0, 50},
{3, 'f', 1, 50}, {3, 'f', 0, 50}, {3, 'a', 1, 50}, {3, 'a', 0, 50}, {2, 'a', 1, 50}, {2, 'a', 0, 50}, {1, 'a', 1, 50}, {1, 'a', 0, 50}
};

__flash struct Frame loop2[] = {
{0, 'a', 1, 50}, {0, 'a', 0, 50}, {0, 'b', 1, 50}, {0, 'b', 0, 50}, {0, 'c', 1, 50}, {0, 'c', 0, 50}, {0, 'd', 1, 50}, {0, 'd', 0, 50},
{1, 'd', 1, 50}, {1, 'd', 0, 50}, {2, 'd', 1, 50}, {2, 'd', 0, 50}, {3, 'd', 1, 50}, {3, 'd', 0, 50}, {3, 'e', 1, 50}, {3, 'e', 0, 50},
{3, 'f', 1, 50}, {3, 'f', 0, 50}, {3, 'a', 1, 50}, {3, 'a', 0, 50}, {2, 'a', 1, 50}, {2, 'a', 0, 50}, {1, 'a', 1, 50}, {1, 'a', 0, 50}
};

__flash struct Frame loop3[] = {
{0, 'a', 1, 50}, {0, 'a', 0, 50}, {0, 'b', 1, 50}, {0, 'b', 0, 50}, {0, 'c', 1, 50}, {0, 'c', 0, 50}, {0, 'd', 1, 50}, {0, 'd', 0, 50},
{1, 'd', 1, 50}, {1, 'd', 0, 50}, {2, 'd', 1, 50}, {2, 'd', 0, 50}, {3, 'd', 1, 50}, {3, 'd', 0, 50}, {3, 'e', 1, 50}, {3, 'e', 0, 50},
{3, 'f', 1, 50}, {3, 'f', 0, 50}, {3, 'a', 1, 50}, {3, 'a', 0, 50}, {2, 'a', 1, 50}, {2, 'a', 0, 50}, {1, 'a', 1, 50}, {1, 'a', 0, 50}
};

Here's main(), up to where the error is thrown (just before init();):

int main(void)
{
    char i = 0, x = 0, y, z, a;
    struct Frame * __flash Animations[3] = {loop1, loop2, loop3};
    init();

Woohoo!  That compiles.  Thanks.  One more question.  How do I access each loopn, as well as each element in loopn?  I'm rusty with pointers.

Thanks, David.  I'm trying to understand this before I try to run it.  Each time through the i loop, a pointer to a structure is created as a constant.  This pointer, f, points to Animations[i].  Animations[] is an array of pointers to arrays of structures.  f steps through each element of Animations[i] via the f++ statement in the j loop, getting incremented 8 times.  Some questions:

1. Why make f a constant?
2. Each Animations[i] has 24 elements, so shouldn't the loop go until j == 24?
3. Is incrementing f once enough to advance it to the next element of Animations[i]?

As I said, my pointer fu is weak.  ;-)

Thanks, David.  I understand logically what you're suggesting, but my compiler doesn't.

struct Frame_descriptor {
    int *Frame;
    int n;
};

int main(void)
{
    int i = 0, x = 0, y, z, a;
    const struct Frame_descriptor __flash *Animations[3] = {
        { loop1, sizeof(loop1}/sizeof(struct Frame) },
        { loop2, sizeof(loop2)/sizeof(struct Frame) },
        { loop3, sizeof(loop3}/sizeof(struct Frame) },
    };

On the first row of *Animations[3] (the one with loop1) it throws, "|198| syntax error; found `,' expecting `}'.  I changed Frame_descriptor since the compiler wasn't accepting it the way you suggested.  This seems to make more sense to me, too, though that may be part of the problem.

> Sharpen your eyes

Whippersnappers making fun of senior citizens!  Is that what this board has come to?  Screw my 59 year old eyes.  I changed the font to 14.

> You have curly braces at the end of some of the sizeof () calls. Should be closing parenthesis.

Thanks for pointing that out.  I chock it up to my eyes, er, font, and carelessly cutting-and-pasting.

Nevertheless, after the fix, the error remains.

David: > My apologies for posting Untested code.

No need to apologize. I'm grateful for any help.

Thanks, Skeeve. I kind of see what you're doing (cols are actually rows?), but I'm away from my computer until tomorrow, so I'll try it when I get back.

Hi, Skeeve.  I get the same error I was getting with David's code:  "invalid struct field declarations" on the Frame *ptr; line below:

#define entry(loop) { loop, sizeof(loop)/sizeof(loop[0]) }

struct loop {
    Frame *ptr;
    uint8_t count;
} raggedbottom[]= {
    entry(loop1),
    entry(loop2),
    entry(loop3),
} ;

Frame and loops are still defined as in my May 10, 2017 - 02:57 PM post, above.

To summarize, I have three loopn arrays of Frame structs listed below, two are the same length and one is different.  I'd like to have an Animations array containing an arbitrary number of these loopn arrays of arbitrary lengths and then select a loopn at random from Animations.  Since I won't know the selected array's length, I'll need to measure it on the fly.  My code so far (developed with the help of everyone in this thread; thanks) allows me to do everything I want except measure the length of each loopn (or Animations[a], below).

struct Frame {
    unsigned char digit;    // Digit:  0 = 1 minutes, 1 = 10 minutes, etc.
    unsigned char seg;      // Segment to turn on:  a - g
    unsigned char onoff;    // 0 = segment off, 1 = segment on
    unsigned char dur;      // Duration in msec. to maintain segment state
};

__flash struct Frame loop1[] = {
{0, 'a', 1, 50}, {0, 'a', 0, 50}, {0, 'b', 1, 50}, {0, 'b', 0, 50}, {0, 'c', 1, 50}, {0, 'c', 0, 50}, {0, 'd', 1, 50}, {0, 'd', 0, 50},
{1, 'd', 1, 50}, {1, 'd', 0, 50}, {2, 'd', 1, 50}, {2, 'd', 0, 50}, {3, 'd', 1, 50}, {3, 'd', 0, 50}, {3, 'e', 1, 50}, {3, 'e', 0, 50},
{3, 'f', 1, 50}, {3, 'f', 0, 50}, {3, 'a', 1, 50}, {3, 'a', 0, 50}, {2, 'a', 1, 50}, {2, 'a', 0, 50}, {1, 'a', 1, 50}, {1, 'a', 0, 50}
};

__flash struct Frame loop2[] = {
{0, 'b', 1, 1}, {0, 'c', 1, 50}, {0, 'b', 0, 1}, {0, 'c', 0, 50}, {0, 'e', 1, 1}, {0, 'f', 1, 50}, {0, 'e', 0, 1}, {0, 'f', 0, 50},
{1, 'b', 1, 1}, {1, 'c', 1, 50}, {1, 'b', 0, 1}, {1, 'c', 0, 50}, {1, 'e', 1, 1}, {1, 'f', 1, 50}, {1, 'e', 0, 1}, {1, 'f', 0, 50},
{2, 'b', 1, 1}, {2, 'c', 1, 50}, {2, 'b', 0, 1}, {2, 'c', 0, 50}, {2, 'e', 1, 1}, {2, 'f', 1, 50}, {2, 'e', 0, 1}, {2, 'f', 0, 50},
{3, 'b', 1, 1}, {3, 'c', 1, 50}, {3, 'b', 0, 1}, {3, 'c', 0, 50}, {3, 'e', 1, 1}, {3, 'f', 1, 50}, {3, 'e', 0, 1}, {3, 'f', 0, 50},
};

__flash struct Frame loop3[] = {
{0, 'a', 1, 50}, {0, 'a', 0, 50}, {0, 'b', 1, 50}, {0, 'b', 0, 50}, {0, 'c', 1, 50}, {0, 'c', 0, 50}, {0, 'd', 1, 50}, {0, 'd', 0, 50},
{1, 'd', 1, 50}, {1, 'd', 0, 50}, {2, 'd', 1, 50}, {2, 'd', 0, 50}, {3, 'd', 1, 50}, {3, 'd', 0, 50}, {3, 'e', 1, 50}, {3, 'e', 0, 50},
{3, 'f', 1, 50}, {3, 'f', 0, 50}, {3, 'a', 1, 50}, {3, 'a', 0, 50}, {2, 'a', 1, 50}, {2, 'a', 0, 50}, {1, 'a', 1, 50}, {1, 'a', 0, 50}
};

void init(void) {
};

int main(void)
{
    int i = 0, x = 0, y, z, a;
    __flash struct Frame * Animations[3] = {loop1, loop2, loop3}
//    __flash struct Frame * __flash Animations[3] = {loop1, loop2, loop3};  // Code works this way and as in previous line
    init();

    for (a = 0; a < 3; a++)
        for (y = 0; y < 5; y++)
            for (i = 0; i < 24; i++) {           // loop2 (Animations[1]) won't play all the way through since it's longer than 24 elements
                if (Animations[a][i].onoff) {
                    segSet(Animations[a][i].seg, Animations[a][i].digit);
                    m_delay(Animations[a][i].dur);
                }
                else {
                    segReset(Animations[a][i].seg, Animations[a][i].digit);
                    m_delay(Animations[a][i].dur);
                }
            }

    while(1)
        ;
    return 0;
}

There have been several suggestions that I create an additional struct to track the size of each loopn, something like this:

struct Frame_descriptor { Frame *film; int siz; };
const struct Frame_descriptor0 __flash *Animations[3] = {
  { loop1, sizeof(loop1} },
  { loop2, sizeof(loop2) },
  { loop3, sizeof(loop3} },
};

I haven't been able to test this, however, as the compiler throws an error on the Frame *film line (or Frame *ptr) in the Frame_descriptor definition:  invalid struct field declarations.  Stefan pointed out that *film should be a pointer to the actual data in flash, but I don't understand this comment as I thought struct definitions are just placeholders; you can't get them to store anything "actual" until you create an instance and initialize it, which you can't do if the compiler won't allow you to define it in the first place.

Anyway, this is where I am, and I really appreciate everyone's patience.

In

struct Frame_descriptor { Frame *film; int siz; };

film is a pointer to a struct called Frame.  How can it be more exact?  While Frame will be stored in flash, 

struct Frame_descriptor { __flash Frame *film; int siz; };
struct Frame_descriptor { const Frame *film; int siz; };

don't compile any better.

Can you explain the difference?  In this code:

struct Frame {
    unsigned char digit;    // Digit:  0 = 1 minutes, 1 = 10 minutes, etc.
    unsigned char seg;      // Segment to turn on:  a - g
    unsigned char onoff;    // 0 = segment off, 1 = segment on
    unsigned char dur;      // Duration in msec. to maintain segment state
};

__flash struct Frame loop1[] = {
{0, 'a', 1, 50}, {0, 'a', 0, 50}, {0, 'b', 1, 50}, {0, 'b', 0, 50}, {0, 'c', 1, 50}, {0, 'c', 0, 50}, {0, 'd', 1, 50}, {0, 'd', 0, 50},
{1, 'd', 1, 50}, {1, 'd', 0, 50}, {2, 'd', 1, 50}, {2, 'd', 0, 50}, {3, 'd', 1, 50}, {3, 'd', 0, 50}, {3, 'e', 1, 50}, {3, 'e', 0, 50},
{3, 'f', 1, 50}, {3, 'f', 0, 50}, {3, 'a', 1, 50}, {3, 'a', 0, 50}, {2, 'a', 1, 50}, {2, 'a', 0, 50}, {1, 'a', 1, 50}, {1, 'a', 0, 50}
};

a struct called Frame is defined and then an array of them is declared and initialized.  This works as intended, so I don't understand the difference you're highlighting.

It's the first thing defined at the top of my code.  Three arrays are initialized containing instances of it.  I can access the Frame array elements, and their parameters.  In what sense does the type not exist?

OK, I can do this:

typedef struct {
    unsigned char digit;    // Digit:  0 = 1 minutes, 1 = 10 minutes, etc.
    unsigned char seg;      // Segment to turn on:  a - g
    unsigned char onoff;    // 0 = segment off, 1 = segment on
    unsigned char dur;      // Duration in msec. to maintain segment state
} Frame;

__flash Frame loop1[] = {
{0, 'a', 1, 50}, {0, 'a', 0, 50}, {0, 'b', 1, 50}, {0, 'b', 0, 50}, {0, 'c', 1, 50}, {0, 'c', 0, 50}, {0, 'd', 1, 50}, {0, 'd', 0, 50},
{1, 'd', 1, 50}, {1, 'd', 0, 50}, {2, 'd', 1, 50}, {2, 'd', 0, 50}, {3, 'd', 1, 50}, {3, 'd', 0, 50}, {3, 'e', 1, 50}, {3, 'e', 0, 50},
{3, 'f', 1, 50}, {3, 'f', 0, 50}, {3, 'a', 1, 50}, {3, 'a', 0, 50}, {2, 'a', 1, 50}, {2, 'a', 0, 50}, {1, 'a', 1, 50}, {1, 'a', 0, 50}
};

__flash Frame loop2[] = {
{0, 'b', 1, 1}, {0, 'c', 1, 50}, {0, 'b', 0, 1}, {0, 'c', 0, 50}, {0, 'e', 1, 1}, {0, 'f', 1, 50}, {0, 'e', 0, 1}, {0, 'f', 0, 50},
{1, 'b', 1, 1}, {1, 'c', 1, 50}, {1, 'b', 0, 1}, {1, 'c', 0, 50}, {1, 'e', 1, 1}, {1, 'f', 1, 50}, {1, 'e', 0, 1}, {1, 'f', 0, 50},
{2, 'b', 1, 1}, {2, 'c', 1, 50}, {2, 'b', 0, 1}, {2, 'c', 0, 50}, {2, 'e', 1, 1}, {2, 'f', 1, 50}, {2, 'e', 0, 1}, {2, 'f', 0, 50},
{3, 'b', 1, 1}, {3, 'c', 1, 50}, {3, 'b', 0, 1}, {3, 'c', 0, 50}, {3, 'e', 1, 1}, {3, 'f', 1, 50}, {3, 'e', 0, 1}, {3, 'f', 0, 50},
};

__flash Frame loop3[] = {
{0, 'a', 1, 50}, {0, 'a', 0, 50}, {0, 'b', 1, 50}, {0, 'b', 0, 50}, {0, 'c', 1, 50}, {0, 'c', 0, 50}, {0, 'd', 1, 50}, {0, 'd', 0, 50},
{1, 'd', 1, 50}, {1, 'd', 0, 50}, {2, 'd', 1, 50}, {2, 'd', 0, 50}, {3, 'd', 1, 50}, {3, 'd', 0, 50}, {3, 'e', 1, 50}, {3, 'e', 0, 50},
{3, 'f', 1, 50}, {3, 'f', 0, 50}, {3, 'a', 1, 50}, {3, 'a', 0, 50}, {2, 'a', 1, 50}, {2, 'a', 0, 50}, {1, 'a', 1, 50}, {1, 'a', 0, 50}
};

typedef struct {
    Frame *film;
    int n;
} Frame_descriptor;

void init(void) {
};

int main(void)
{
    int i = 0, x = 0, y, z, a;
    __flash Frame_descriptor *Animations[3] = {
        { loop1, sizeof(loop1)/sizeof(Frame) },
        { loop2, sizeof(loop2)/sizeof(Frame) },
        { loop3, sizeof(loop3)/sizeof(Frame) },
    };
    init();

but then the compiler says, "syntax error; found `,' expecting `}'," on the line beginning with loop1 in the *Animations array.