no control of bot when kicker is operating

[Ether]

What you've posted is essentially a state machine, where the state variable is the value of kickTimer.

A generic state machine might look like this:

// Set kicking loop to start when button 7 on gamepad is pressed and not in loop already


switch(kickState) {

case 0: // kicking is not in progress

if(gamePad.getRawButton(7) == true) {
start_the_kick_sequence_and_initialize_variables_a s_necessary();
kickState = 1;
}
break;

case 1:

if case_1_timer_or_event_has occurred(){
perform_case_1_action();
initialize_variables_for_case_2_as_necessary();
kickState=2;
}
break;

case 2:

if case_2_timer_or_event_has occurred(){
perform_case_2_action();
initialize_variables_for_case_3_as_necessary();
kickState=3;
}
break;

.
.
.


case n:

if case_n_timer_or_event_has occurred(){
perform_casen2_action();
initialize_variables_for_case_0_as_necessary();
kickState=0;
}
break;

}

The above has the advantage that it's a little easier to see how to use events (like limit switches etc) to change states, instead of being strictly timer-based.


~

[synth3tk]

Thanks for the suggestions. I should have also stated:

I'm a non-student member (I guess a mentor, in some ways), and our team is extremely small. I couldn't even coerce any students to learn programming, so I had to learn Java with some small help from the team mentor (who knew very little more about Java than I did) and the internet starting 2 days from Kick-Off.

We were just getting the bare minimum working. But I'll keep that in mind for the future, if/when we teach the new programmers.

[Ether]

I've seen the following kicker approach successfully implemented in LabVIEW. The same approach could be used in Java or C++.

put the following code in a separate concurrent periodic task using your language of choice. for a kicker, 20Hz is probably plenty fast enough.

/*
to establish the 50ms period (20Hz frequency) put your code here 
to block wait for 50ms to elapse, releasing the CPU so this task 
does not run at high speed and use CPU resources unnecessarily 
when not kicking
*/

if (kickRequested && !kicking) {

kicking=1; // prevent reentrancy

/*
put your sequential kicking code here.

if your code has places where it needs to wait for an event, 
like elapsed time or a limit switch for example, 
make sure you code it so that the CPU will be released 
to use that time to service other tasks 
while waiting for the event.

if your code uses data from other tasks, 
make sure the access is protected.
*/

kicking=0;

}

"kickRequested" is a global boolean that is used by your code in Autononmous and/or TeleOp to request that a kick be performed.

"kicking" is a local boolean to control reentrancy: If a kick is presently in progress when the request is made, the request will be ignored (so as not to interrupt the ongoing kick cycle)

[timothyb89]

One thing I liked doing for the kicker code was making sure you couldn't violate the timing rules (2 seconds between extensions out of the main robot body), and tossing in a few extra threads made it fit together nicely. Obviously reload time can make this unneeded, so it might not even be needed, depending.

Example code here.