Search code examples
carraysatmega32

How do I correctly create a copy of an array in C or set a reference to one?

so, I'm very new to C, coming from a Java/C# background and I can't quite wrap my head around it so far.

What I'm trying to do is program a microcontroller (Adafruit Feather running an atmega32u4 in this case) to pose as a USB-coupled controller for Nintendo Switch and run automated commands.

The project I'm trying to expand upon is using a struct array of commands like this:

typedef struct {
    Buttons_t button;
    uint16_t duration; // 1 equals 0.025s on ATmega32u4 => 1s = 40
} command;

static const command loop[] = {
    // do stuff
                        { NOTHING,  150 },
    { TRIGGERS,   15 }, { NOTHING,  150 },
    { TRIGGERS,   15 }, { NOTHING,  150 },
    { A,          5 },  { NOTHING,  250 }
};

Now initially this was all there was to it, the program would loop through the commands, send a button to the console and "hold" it for the defined period of time. When the program ran to the end of the array, it would simply reset the index and start anew.

Now I'm trying to send different commands to the console, based on a few easy if..else queries. Specifically, the program will start with a day, month and year variable (the date the Switch console is currently set to) and roll days forward individually to get to a set date in the future. To this end, I want to check at every 'step' if the date +1 day is valid as described in this tutorial and based on the result either roll one day, one day and one month or one day, one month and one year forward. Then I want it to end after a set amount of days.

I wrote several arrays of commands to represent the different steps needed for setting up the controller, moving to where it's supposed to loop, rolling a day, a month or a year like this:

static const command setupController[] = {
    // Setup controller
    ...
};

static const command moveToLoop[] = {
    // Go into date settings
    ...
};

static const command rollDay[] = {
    //roll to next day
    ...
};

static const command rollMonth[] = {
    //roll to next month
    ...
};

static const command rollYear[] = {
    //roll to next year
    ...
};

And another array I want to copy those to like this:

#define COMMANDMAXSIZE 100
static command activeCommand[COMMANDMAXSIZE];

I know this is (extremely) wasteful of memory, but I'm definitely not good enough at C to come up with fancier, more conservative solutions yet.

Then I go into my program, which looks like this:

int main(void) {
    SetupHardware(); //Irrelevant, because it is exactly like I downloaded it and it works even with the bumbling changes I've made
    GlobalInterruptEnable(); //Ditto

    RunOnce(setupController);

    RunOnce(moveToLoop);

    while (daysSkipped != stopDay)
    {
        if (datevalid((dayOfMonth + 1), month, year)) {
            dayOfMonth++;
            RunOnce(rollDay);
        }
        else if (datevalid(1, (month + 1), year)) {
            dayOfMonth = 1;
            month++;
            RunOnce(rollMonth);
        }
        else if (datevalid(1, 1, (year + 1))) {
            dayOfMonth = 1;
            month = 1;
            year++;
            RunOnce(rollYear);
        }

        daysSkipped++;
    }
}

and finally (I swear I'll be done soon), the start of RunOnce looks like this

void RunOnce(command stepsToRun[]) {
    memcpy(activeCommand, stepsToRun, sizeof(activeCommand)); //set the setup commands to be active
    activeBounds = sizeof(stepsToRun) / sizeof(stepsToRun[0]);
    ...

Later in the program, the task that translates commands into button presses for the console actually runs one fixed array, so I figured I'd just "mark" the commands to run as active, and only ever run the active array. Only, it doesn't work as expected:

The program runs, sets up the controller, moves to the date settings and indeed starts to roll a date, but then, regardless if the next day is valid or not, it rolls forward a month, then a year and then it gets stuck moving the simulated analog stick upwards and pressing A indefinitely.

I figure the problem lies in my memcpy to overwrite the active array with the steps I want to run next, but I can't think of a way to solve it. I tried writing a function that was supposed to overwrite the active array element by element using a for loop, but this way the controller wouldn't even set itself up correctly and effectively nothing happened. Usually with any kind of output capabilities I'd try to fit in prints at points of interest, but I have virtually no way of getting feedback on my microcontroller.

Any help would be greatly appreciated.

Solution

  • Ignoring that doing a hard copy of the data is incredibly slow and wasteful, it is also incorrect indeed.

    memcpy(activeCommand, stepsToRun, sizeof(activeCommand));

    Here you need to copy the size of the data you pass on, not the size of the target buffer! Right now you end up copying more data than you have, because all of these declarations static const command rollDay[] etc get a variable size depending on the number of items in the initializer list.

    The quick & dirty fix to your immediate problem would be to pass along the size:

    void RunOnce(size_t size, command stepsToRun[size])
{
    memcpy(activeCommand, stepsToRun, size);

    and then call this function with RunOnce(sizeof rollDay, rollDay); etc.

    The activeBounds = sizeof(stepsToRun) / sizeof(stepsToRun[0]); part is also incorrect but not the immediate reason for the bug. See How to find the 'sizeof' (a pointer pointing to an array)? and What is array to pointer decay? etc.