util.hpp

Go to the documentation of this file.

/*
This Source Code Form is subject to the terms of the Mozilla Public
License, v. 2.0. If a copy of the MPL was not distributed with this
file, You can obtain one at http://mozilla.org/MPL/2.0/.
*/
 
#pragma once
 
#include <algorithm>
#include <atomic>
#include <cmath>
#include <cstdint>
#include <cstdio>
#include <cstring>
#include <functional>
#include <iomanip>
#include <iostream>
#include <memory>
#include <sstream>
#include <string>
#include <vector>
 
#include "LightLib/api.h"
#include "light/units.hpp"
 
using namespace okapi::literals;
 
extern pros::Controller master;
 
namespace light {
 
void ez_template_print();
 
void screen_print(std::string text, int line = 0);
 
enum e_type { SINGLE = 0, 
              SPLIT = 1 };
 
enum e_swing { LEFT_SWING = 0,  
               RIGHT_SWING = 1 };
 
enum exit_output { RUNNING = 1,            
                   SMALL_EXIT = 2,         
                   BIG_EXIT = 3,           
                   VELOCITY_EXIT = 4,      
                   mA_EXIT = 5,            
                   ERROR_NO_CONSTANTS = 6 };
 
enum e_mode { DISABLE = 0,       
              SWING = 1,         
              TURN = 2,          
              TURN_TO_POINT = 3, 
              DRIVE = 4,         
              POINT_TO_POINT = 5,
              PURE_PURSUIT = 6 };
 
enum drive_directions { FWD = 0,
                        FORWARD = FWD,
                        fwd = FWD,
                        forward = FWD,
                        REV = 1,
                        REVERSE = REV,
                        rev = REV,
                        reverse = REV };
 
enum e_angle_behavior { raw = 0,                
                        left_turn = 1,          
                        LEFT_TURN = 1,
                        counterclockwise = 1,
                        ccw = 1,
                        right_turn = 2,         
                        RIGHT_TURN = 2,
                        clockwise = 2,
                        cw = 2,
                        shortest = 3,           
                        longest = 4 };          
 
const double ANGLE_NOT_SET = 0.0000000000000000000001;
const okapi::QAngle p_ANGLE_NOT_SET = 0.0000000000000000000001_deg;
 
typedef struct pose {
  double x;                    
  double y;                    
  double theta = ANGLE_NOT_SET;
} pose;
 
typedef struct united_pose {
  okapi::QLength x;                      
  okapi::QLength y;                      
  okapi::QAngle theta = p_ANGLE_NOT_SET; 
} united_pose;
 
typedef struct odom {
  pose target;                                  
  drive_directions drive_direction;             
  int max_xy_speed;                             
  e_angle_behavior turn_behavior = shortest;    
} odom;
 
typedef struct united_odom {
  united_pose target;                           
  drive_directions drive_direction;             
  int max_xy_speed;                             
  e_angle_behavior turn_behavior = shortest;    
} united_odom;
 
std::string exit_to_string(exit_output input);
 
namespace units {
inline constexpr double MM_PER_IN = 25.4;          
inline constexpr double IN_PER_MM = 1.0 / 25.4;    
inline constexpr double M_PER_IN = 0.0254;         
inline constexpr double IN_PER_M = 1.0 / 0.0254;   
inline constexpr double DEG_PER_RAD = 180.0 / M_PI;
inline constexpr double RAD_PER_DEG = M_PI / 180.0;
}  // namespace units
 
namespace util {
extern bool AUTON_RAN; 
 
int places_after_decimal(double input, int min = 0);
 
std::string to_string_with_precision(double input, int n = 2);
 
int sgn(double input);
 
bool reversed_active(double input);
 
double clamp(double input, double max, double min);
 
double clamp(double input, double max);
 
const bool SD_CARD_ACTIVE = pros::usd::is_installed();
 
const int DELAY_TIME = 10;
 
double to_deg(double input);
 
double to_rad(double input);
 
double absolute_angle_to_point(pose itarget, pose icurrent);
 
double distance_to_point(pose itarget, pose icurrent);
 
double wrap_angle(double theta);
 
inline float wrap_rad(float a) {
  return std::atan2(std::sin(a), std::cos(a));
}
 
pose vector_off_point(double added, pose icurrent);
 
double turn_shortest(double target, double current, bool print = false);
 
double turn_longest(double target, double current, bool print = false);
 
pose united_pose_to_pose(united_pose input);
 
std::vector<odom> united_odoms_to_odoms(std::vector<united_odom> inputs);
 
odom united_odom_to_odom(united_odom input);
 
}  // namespace util
}  // namespace light