sleep()

[Yellow Eyes]

In our code, we want to use the sleep() function. When we try to compile we get an error saying it can't find the function sleep(). What would we need to include in order to get this to work?

[KenWittlief]

I dont think you want to use any of the sleep modes - there is code that has to run for the RC to function correctly - the code runs in one continious loop - if you put the uP to sleep, it will stop till an interrupt occurs - I think it would cause the RC to lock up or reset on you.

Sleep modes are normally for low power applications, like PDAs or cell phone - your bot will be drawing 50 to 100 amps during a match, so whats 0.1 Amps more or less going to accomplish?

[Yellow Eyes]

what about a pause function? Same results?

[KenWittlief]

same problem, you have to let the main loop run, or the code that is buried in the RC (that we dont see) will say "hey, the user code stopped running, turn off all the victors and relays until it comes back"

( of course it says that in binary: 00011000101010101101101 :c)

[Yellow Eyes]

I was just informed it will be sleep(1); will that 1 millisecond make a difference and cause those problems?

[SeanCassidy]

What you could do(for autononmous) was have a start time and an end time to all things. Sort of like this:

//Autonomous code
go(1,0,18);   //Go forward (1 = fwd, 2 = rev), start at 0, and end at 1800ms
turn(1,19,25);  //Turn (1 = left, 2 = right), start at 1900ms end at 2500ms
//Notice the 1000ms delay!
moveArm(2,35,40); //Move arm ( 1 = up, 2 = down), start at 3500ms end at 4000ms

Of course, you'll need to use interrupts (use the white paper from Innovation First), and add a static counter to the t100msDelay, for increments of 100ms. More precision that using seconds. But, the way you should do it is it just sets a pwm (or whatever) equal to the correct value, and move on, when it comes back (you'll have to make it know that it already completed one and it's time to finish up) just set it to 127 or whatever. Very useful and very effective.

[Astronouth7303]

So is there a way to 'wait' while still having interrupts going? this would be the easiest way to write a Autonomous Script. You know, Left=255;Right=255;Wait(600);.

[mtrawls]

Originally Posted by Astronouth7303

So is there a way to 'wait' while still having interrupts going? this would be the easiest way to write a Autonomous Script. You know, Left=255;Right=255;Wait(600);.

I'm sorry, but I don't understand what the advantage is of waiting. Why would you need to pause at a specific instruction for some amount of time? What would you need to do in auton mode that couldn't be accomplished by having a state where the drive motors are sent neutral values? You could just be sitting still "waiting" for some input to come your way ... but you don't need to mess with timer's at all. I just don't see the need, so please explain if I am mistaken ...

[ChrisA]

There's something called a "FOR LOOP". In this loop, you can specify how long it stays in the loop. You could increment a variable there if you wanted to 'wait' for a certain amount of time. Or, you could use what we like to call a "TIMER". Timers count time. Time can be used for waiting.

Maybe you should be a little more specific on what you're trying to do.

[deltacoder1020]

Originally Posted by ChrisA

There's something called a "FOR LOOP". In this loop, you can specify how long it stays in the loop. You could increment a variable there if you wanted to 'wait' for a certain amount of time. Or, you could use what we like to call a "TIMER". Timers count time. Time can be used for waiting.

Maybe you should be a little more specific on what you're trying to do.

but do remember that you need to call putdata every 26.2ms or so, or else the processor will shut down, which would not be a good thing in the middle of a match.

[Ryan M.]

Originally Posted by ChrisA

There's something called a "FOR LOOP". In this loop, you can specify how long it stays in the loop. You could increment a variable there if you wanted to 'wait' for a certain amount of time. Or, you could use what we like to call a "TIMER". Timers count time. Time can be used for waiting.

Maybe you should be a little more specific on what you're trying to do.

If you care, the struture of the for loop is this:

for(initiazation; test; increment)
{
    // body of loop
}

It is more flexible than that form indicates, but that would be the most common way to use it. A quick example of it actually being used as a "pause."

// Somewhere at the top
unsigned int i;

// Later on
for(i = 0; i < 10; i++)
{
    // Do nothing
}

This code would cause it to loop ten times and then continue.

Note that if you were using this as a timer, it would be different at different battery charges as the controller would run slower.

Anyways, if anyone cares, there it is.

[jacob_dilles]

instead of going to sleep, i would count loops till the required delay has passed. stoping a program is a bad thing, just because of the way the program loop is structured. if that doesnt work, i would use a timer with an inturupt.

[KenWittlief]

Note that if you were using this as a timer, it would be different at different battery charges as the controller would run slower.

?!?!?!?!

the microprocessor runs on 5V, regulated from the 12 or 7.2V batteries - and the timing is controlled by a crystal that doesnt care what the battery voltages are

the execution of uP instruction cycles will be dead accurate repeatable, no matter what the state of your battery is, until the battery drops far enough to cause a reset.

I think the people that are contemplating wait states, for loops, do loops or while loops in their code really need to get the default users manaul and get a grasp on how this SW runs

the program takes in inputs from the operator
then it does your processing
then it outputs the results of your processing to the victors and spikes

those three major tasks repeat continiously - you DONT want to pause or stop or put timing delays in your processing area - you want the code to continue to run and loop as fast as it can

so if you are waiting for something to happen, and it hasnt happend yet, then do nothing and check again on the next 'pass' of the SW.

Putting wait states or delays in your code is one of the surest ways to make the controller lock up, and set all your outputs to 'off' - when this happens your bot will go dead and you will have a very expensive, very fancy statue sitting on the field infront of 3000 people.

[kristen]

Ok, you'll need two global variables (put them in user_routines_fast.c, or something):
Code:

unsigned int delay_count = 0;
unsigned int delay_constant = 0;
enum {PROGRAM_RUNNING, PROGRAM_DELAY} program_state = PROGRAM_RUNNING;

Have a function:
Code:

void delay(unsigned int count)
{
    if (!delay_constant) {
        delay_constant = count;
        delay_count = 0;
        program_state = PROGRAM_DELAY;
    }
    if (delay_count >= delay_constant) {
        delay_constant = delay_count = 0;
        program_state = PROGRAM_RUNNING;
    } else {
        delay_count += 26;
    }
}

This function should be called something like this: (in user_routines_fast.c)
Code:

 Getdata(&rxdata);   /* DO NOT DELETE, or you will be stuck here forever! */

         if (PROGRAM_RUNNING == program_state) {
             /* Add your own autonomous code here. */
         } else {
             delay(0);
         }

        Putdata(&txdata);   /* DO NOT DELETE, or you will get no PWM outputs! */
    }

Now, anytime you want to set a delay, simply have a call to delay(milliseconds) somewhere in the autonomous code.

Most of this might not compile.

.. A certain programmer on my team who is unnamed is tooo shy to post this himself! ;D

[Astronouth7303]

My thought was that after it's done waiting, you set a new value. And just do a putdata and a getdata in the loop.