Encapsulación de movimientos básicos de robots en VEXcode Pro V5

El objetivo principal es mostrarle cómo encapsular algunos de los códigos de movimiento fundamentales en funciones, no para el cálculo del codificador y las manipulaciones de movimiento.

Las siguientes funciones de movimiento de muestra le ayudarán a crear su código de movimientos básico:

• Más organizado
• Más legible
• Menos propenso a errores

En primer lugar, deberás definir las siguientes variables básicas:

float Wheel = 10.16;
Float WB = 36.75;   //basado en la configuración V5 Clawbot

Nota: Si cambia la relación de transmisión, el siguiente cálculo puede cambiar ligeramente en función de la relación de transmisión.

Esto se discutirá en otro artículo centrado en el codificador del motor:

float EncPerCm = 360/(rueda* M_PI);
float EncPerDeg = WB/Rueda;

Esta muestra es solo para giro de pivote. P. ej. motor derecho = 100, motor izquierdo = -100, etc.

En segundo lugar, cuando revise las siguientes muestras, le recomendamos que busque en la referencia de la API en línea los parámetros y sus especificaciones. Visite: https://api.vexcode.cloud/v5/html/ y busque, por ejemplo , rotateTo para familiarizarse con los parámetros.

---

Muestra 1: Encapsular el movimiento recto en función de varias distancias

float Wheel = 10.16; 
float WB = 36.75; 
float EncPerCm = 360.0 / (Wheel* M_PI); 

void reportMotionValues (motor m, int line){Brain.Screen.printAt (5,line, "%8.2lf%8.2lf%8.2f", m.position (rev), m.position (deg)); 
}

// distance is in centimeters
void goStraight ( float distance ){

 
 

	
	LeftMotor.resetPosition ();
	LeftMotor.resetRotation ();
	RightMotor.resetPosition ();
	RightMotor.resetRotation ();
  	
	float totalEnc = distance * EncPerCm;
	
	// note:  “deg” is from the vex:: namespace. Por lo tanto, no debe 
        // crear otra variable también llamada "deg". 

       LeftMotor.setVelocity(50.0, percent); LeftMotor.spinToPosition (totalEnc, deg, false); RightMotor.setVelocity (50.0, percent); RightMotor.spinToPosition (totalEnc, deg, false);

       while (LeftMotor.isSpinning () || RightMotor.isSpinning () ) 
            wait(50, msec);

 


  	
	return;
}

int main() {  
  vexcodeInit ();

    goStraight (100.0);
    Brain.Screen.printAt (5,60, "Done");
    reportMotionValues (LeftMotor, 30);
    reportMotionValues (RightMotor, 60); 
}

---

Muestra 2: Encapsular giros a la izquierda basados en varios grados

float Wheel = 10.16; 
float WB = 36.75; 
float EncPerCm =  360.0 / (Wheel* M_PI); 
float EncPerDeg =  WB / Wheel;

void turnRight( float degrees){	 	LeftMotor.resetPosition
	
	(); 	LeftMotor.resetRotation
	(); 	RightMotor.resetPosition
	(); 	RightMotor.resetRotation
	();
  	
	float totalEnc = degrees * EncPerDeg;
	
       // note: este “deg” es del espacio de nombres de
       Vex LeftMotor.setVelocity (100.0, percent)
       ; LeftMotor.spinToPosition (totalEnc, deg, false)
 
       ; RightMotor.setVelocity (-100.0, percent)
       ; RightMotor.spinToPosition (-totalEnc, deg, false);

       while(LeftMotor.isSpinning () || RightMotor.isSpinning () 
          wait(50, msec);
  	
	return;
}

main(int){
...)
   turnRight(90.0);
   ...
}

---

Muestra 3: encapsular tanto a la izquierda como a la derecha en una sola función

void doTurning( float degrees ) {
	// exactamente el mismo código que el turnRight de arriba
}

int main() {
    ...
   doTurning(90.0);  // Giro de pivote derecho
   ...
   doTurning(-90.0); // Giro de pivote izquierdo
}

Para una programación más avanzada, si desea que su código sea mucho más legible, puede probar lo siguiente:

#define doLeftTurn(d)    doTurning(d)
#define doRigtTurn(d)    doTurning(-d)

int main() {
   ...
   doLeftTurn(90.0);  
   doRightTurning(90.0);
   ...
}

#define se llama una expresión de macro de preprocesador. Observa esta expresión como un símbolo. Siempre que este símbolo aparezca en el código, se reemplazará con la expresión doTurning(el valor especificado).

La macro del preprocesador es un tema extenso diferente y no se discutirá en este artículo.