void reset_op()
{
encoderReset(rf_encoder);
encoderReset(lf_encoder);
encoderReset(rb_encoder);
encoderReset(lb_encoder);
}
int gofor(int llen, int rlen, int turn, int forward) {
encoderReset(r_encoder);
encoderReset(l_encoder);
int ol=0;
int or=0;
dstat=0;
printf("going for %d\t%d degrees with dir %d\t%d\n\r",llen,rlen,turn,forward);
#ifndef SIM
while((abs(encoderGet(l_encoder))<llen &&abs(encoderGet(r_encoder))<rlen)){
c_status("gofor",llen);
controldrive(turn,forward);
simtank(<ank,encoderGet(l_encoder-ol)-ol,encoderGet(r_encoder)-or);
ol=encoderGet(l_encoder);
or=encoderGet(r_encoder);
delay(20);
}
#endif
dstat=1;
controldrive(0,0);
printf("Motion complete, expected:");
printpos(&ctank);
printf("\tintegrated: ");
printpos(<ank);
printf("\n\r");
return encoderGet(l_encoder)>encoderGet(l_encoder) ? encoderGet(l_encoder) : encoderGet(r_encoder);
}
void driveForward(int encoder_value){
while((encoderGet(frontLeftEncoder)+ encoderGet(frontRightEncoder))/2 < encoder_value){
motorSet(front_left_drive, -127);
motorSet(front_right_drive, 127);
motorSet(back_left_drive, -127);
motorSet(back_right_drive, -127);
}
encoderReset(frontLeftEncoder);
encoderReset(frontRightEncoder);
}
void turnLeft(int encoder_value){
while(((-1*encoderGet(frontLeftEncoder)) + encoderGet(frontRightEncoder))/2 > encoder_value){
motorSet(front_left_drive, 127);
motorSet(front_right_drive, 127);
motorSet(back_left_drive, 127);
motorSet(back_right_drive, - 127);
}
encoderReset(frontLeftEncoder);
encoderReset(frontRightEncoder);
}
void armbotRed()
{
encoderReset(TOWER_ENCODER);
printf("ENCODER %x reset\n\r",TOWER_ENCODER);
int stackRot = 3360;
int loadRot = 100;
int loadHeight = 70;
int loadHeightHigh = 376 +30; //30 is error
int wallHeightU = loadHeightHigh; // idk
int wallHeight = loadHeight; // idk
int spike1 = -6; // heights for the individual spikes!
int spike2 = 450; //n*(offset+ drift)
//150 = 450-300 release height
int spike3 = 800;
int spike4 = 0;
int spike5 = 0;
int spike6 = 0;
int pot = analogRead (8);
int wall = 980; //pot value
int stack = 3360; // pot value
int center = (stack-wall)/2;
/////////////////////////////////////spike 1//////////////////////////////////////////
armUpEnc(wallHeight);
turnRightSlow(wall);
intake(300); //clamp it!
armUpEnc(wallHeightU); // pick it up
turnLeftSlow(stack); // rotate to stack
armDownEnc(spike1); //score the spike!
outtake(300);
armUpEnc(spike1 + 500);
turnRightSlow(center);
// and loop!/////////////////////spike 2//////////////////////////
armUpEnc(wallHeightU);
turnRightSlow(wall);
intake(300); //clamp it!
armUpEnc(spike2 + 100); // pick it up + go abit higher than spike height!
turnLeftSlow(stack); // rotate to stack
delay(500); // wait for swing to stop!
armDownEnc(spike1); //score the spike!
outtake(300);
armUpEnc(spike2 + 500);
turnRightSlow(center);
//end of routine
stopAll () ;
delay(60000);///////////////////////////////////////////////////////////////////////////////////
}
void test_init() {
TEST_ASSERT_EQUAL(0, encoderState(encoder));
TEST_ASSERT_EQUAL(0, getEncoderError(encoder).errors);
TEST_ASSERT_EQUAL(0, getEncoderError(encoder).errorMask);
encoderReset(encoder, 100);
TEST_ASSERT_EQUAL(100, encoderState(encoder));
}
/*
* Runs the user operator control code. This function will be started in its own task with the
* default priority and stack size whenever the robot is enabled via the Field Management System
* or the VEX Competition Switch in the operator control mode. If the robot is disabled or
* communications is lost, the operator control task will be stopped by the kernel. Re-enabling
* the robot will restart the task, not resume it from where it left off.
*
* If no VEX Competition Switch or Field Management system is plugged in, the VEX Cortex will
* run the operator control task. Be warned that this will also occur if the VEX Cortex is
* tethered directly to a computer via the USB A to A cable without any VEX Joystick attached.
*
* Code running in this task can take almost any action, as the VEX Joystick is available and
* the scheduler is operational. However, proper use of delay() or taskDelayUntil() is highly
* recommended to give other tasks (including system tasks such as updating LCDs) time to run.
*
* This task should never exit; it should end with some kind of infinite loop, even if empty.
*/
void operatorControl() {
encoderReset(encoder);
while (1) {
int distance = encoderGet(encoder);
printf("%d\n\r", distance);
delay(20);
}
}
void flywheelReset(Flywheel *flywheel)
{
flywheel->derivative = 0.0f;
flywheel->integral = 0.0f;
flywheel->error = 0.0f;
flywheel->action = 0.0f;
flywheel->lastAction = 0.0f;
flywheel->lastError = 0.0f;
flywheel->firstCross = true;
flywheel->reading = 0;
encoderReset(flywheel->encoder);
}
void autonomous() {
Encoder leftEnc; //Sets encoder variable
Encoder rightEnc;
leftEnc = encoderInit(1, 2, 0); //Points to encoders
rightEnc= encoderInit(3, 4, 0);
encoderReset(leftEnc); //Resets Encoder
encoderReset(rightEnc);
int leftVal; //Initializes value variable
int rightVal;
leftVal = encoderGet(leftEnc); //Gets initial value for encoder
rightVal= encoderGet(rightEnc);
motorSet(1, 127); //Motors Forward
motorSet(2, 127);
motorSet(9, -127);
motorSet(10, 127);
while(leftVal <= 360 && rightVal <= 360) {
leftVal = encoderGet(leftEnc); //Gets encoder value
rightVal= encoderGet(rightEnc);
}
motorSet(1, 0); //Stops Motors
motorSet(2, 0);
motorSet(9, 0);
motorSet(10, 0);
}
void calibrate(){
if (bot == calib){
wind(joystickGetAnalog(1, 3));
if (joystickGetDigital(1, 7, JOY_RIGHT)){
encoderReset(encode);
}
}
int oldval = leftdraw;
//raise the left shooting value
while (joystickGetDigital(1, 7, JOY_UP)){
leftdraw = oldval - 5;
delay(25);
}
//lower left shooting value
while (joystickGetDigital(1, 7, JOY_DOWN)){
leftdraw = oldval + 5;
delay(25);
}
oldval = rightdraw;
//raise right shooting value
while (joystickGetDigital(1, 8, JOY_UP)){
rightdraw = oldval + 5;
delay(25);
}
//lower left shooting value
while (joystickGetDigital(1, 8, JOY_DOWN)){
rightdraw = oldval - 5;
delay(25);
}
char buf[16];
sprintf(buf, "R: %d L: %d", rightdraw, leftdraw);
lcdSetText(uart1, 2, buf);
}
void startSensor(Sensor *s) {
switch (s->type) {
case SHAFT_ENCODER:
encoderReset(s->enc);
if (DEBUG) {
print("reset encoder");
}
break;
case GYROSCOPE:
gyroReset(s->gyr);
break;
case TIME:
//resetTimer(s->port, true);
startTimer(s->port, true);
break;
case IME:
imeReset(s->port);
break;
default:
break;
}
}
void quadEncoderReset(QuadEncoder encoder) {
encoderReset(encoder.encoder_data);
}
/*
* Runs the user autonomous code. This function will be started in its own task with the default
* priority and stack size whenever the robot is enabled via the Field Management System or the
* VEX Competition Switch in the autonomous mode. If the robot is disabled or communications is
* lost, the autonomous task will be stopped by the kernel. Re-enabling the robot will restart
* the task, not re-start it from where it leftLine off.
*
* Code running in the autonomous task cannot access information from the VEX Joystick. However,
* the autonomous function can be invoked from another task if a VEX Competition Switch is not
* available, and it can access joystick information if called in this way.
*
* The autonomous task may exit, unlike operatorControl() which should never exit. If it does
* so, the robot will await a switch to another mode or disable/enable cycle.
*/
void autonomous()
{
// jumper in = 1
int jumper1 = digitalRead (1);
int jumper2 = digitalRead (2);
int jumper3 = digitalRead (3);
encoderReset(TOWER_ENCODER);
if (jumper2 == 1) // this is gordons last sec brute force method cuz theres no time //jumper 2 in
{// jumper 2 in
armbotRed();
}
AutonomousMode mode = (jumper3) | (jumper2 << 1) | (jumper1 <<2);
printf("Entered autonomous mode %d\n\r",mode);
encoderReset(TOWER_ENCODER);
printf("ENCODER %x reset\n\r",TOWER_ENCODER);
//jumper 1 = MSB // jumper 3 = LSB
armbotRed();
//armTest();
/*
switch(mode)
{
case BLUE_RESERVED0: // 0 0 0
armbotRed();;
break;
case BLUE_RESERVED1: // 0 0 1
stackEm();
break;
case BLUE_RESERVED2: // 0 1 0
stackEm();
break;
case BLUE_RESERVED3: // 0 1 0
//mode3()
break;
case RED_RESERVED4: // 1 0 0
stackEm();
break;
case RED_RESERVED5: // 1 0 1
stackEm();
break;
case RED_RESERVED6: // 1 1 0
stackEm();
break;
default:
printf("Jumpers are set to unkown configuration\n\r");
stackEm();
break;
}
*/
// all jumper comands here:
//1 = out
// 0 = in
/*
if ((jumper1 == 1) ) // jumper in 1 = red autonomous
{
armbotRed();
}
if (jumper2 == 0) // jumper 2 in = blue auto
{
//rejectionBlue();
}
*/
//allstop
stopAll();
delay(600000);
}
/*
* Runs the user operator control code. This function will be started in its own task with the
* default priority and stack size whenever the robot is enabled via the Field Management System
* or the VEX Competition Switch in the operator control mode. If the robot is disabled or
* communications is lost, the operator control task will be stopped by the kernel. Re-enabling
* the robot will restart the task, not resume it from where it left off.
*
* If no VEX Competition Switch or Field Management system is plugged in, the VEX Cortex will
* run the operator control task. Be warned that this will also occur if the VEX Cortex is
* tethered directly to a computer via the USB A to A cable without any VEX Joystick attached.
*
* Code running in this task can take almost any action, as the VEX Joystick is available and
* the scheduler is operational. However, proper use of delay() or taskDelayUntil() is highly
* recommended to give other tasks (including system tasks such as updating LCDs) time to run.
*
* This task should never exit; it should end with some kind of infinite loop, even if empty.
*/
void operatorControl() {
//Config variables 'n stuff
bool autoM = false;
bool first = true;
bool reset = true;
const int LFRONT=1;
const int LBACK=2;
const int RFRONT=3;
const int RBACK=4;
const int WINCH1=5;
const int WINCH2=6;
const int FLAGDWN=7;
long startM;
long endM;
double circ;
double MPH;
//main loop
while (1) {
//motorSet(2,50);
//auto code
autoM = joystickGetDigital(1, 8, JOY_LEFT);
if (autoM && first) {
autonomous();
first = false;
}
//delay(20);
//Teleop code
if (joystickGetDigital(1, 7, JOY_UP)) { //Drive straight
int speed = joystickGetAnalog(1, 3);
motorSet(LFRONT, speed);
//delay(5);
motorSet(LBACK, speed);
//delay(5);
motorSet(RFRONT, speed);
//delay(5);
motorSet(RBACK, speed);
//delay(5);
} else { //tank drive
int LSpeed = joystickGetAnalog(1, 3);
int RSpeed = joystickGetAnalog(1, 2);
motorSet(LFRONT, LSpeed);
motorSet(LBACK, LSpeed);
motorSet(RFRONT, RSpeed);
motorSet(RBACK, RSpeed);
}
//Winch 1
if (joystickGetDigital(1, 5, JOY_UP)) {
motorSet(WINCH1, 60);
} else if (joystickGetDigital(1, 5, JOY_DOWN)) {
motorSet(WINCH1, -60);
}
else motorSet(WINCH1, 0);
//Winch 2
if (joystickGetDigital(1, 6, JOY_UP)) {
motorSet(WINCH2, 60);
} else if (joystickGetDigital(1, 6, JOY_DOWN)) {
motorSet(WINCH2, -60);
}
else motorSet(WINCH2, 0);
//Flag
if (joystickGetDigital(1, 8, JOY_DOWN)) {
motorSet(FLAGDWN, 60);
}
else if (joystickGetDigital(1,8, JOY_UP)){
motorSet(FLAGDWN, -60);
}
else motorSet(FLAGDWN, 0);
//Anemometer
if(reset){
startM=micros();
encoderReset(ameter);
reset=false;
}
long reading = encoderGet(ameter);
if(reading/360==4){
endM=micros();
double revPerSec = (4.0*pow(10.0, 6.0))/((double)(startM-endM));
double revPerMin = revPerSec*60.0;
MPH = circ/12.0/5280.0*revPerMin*60.0;
reset=true;
}
//Flush Data
delay(20);
}
}