Merge branch 'V2' of https://github.com/NoozAbooz/210K-HighStakes-2025 …

…into V2

.github/workflows/build.yml

@@ -50,4 +50,4 @@ jobs:
         uses: actions/checkout@v3
 
       - name: Build PROS Project  
-        run: pros make clean all
+        run: make -j

Makefile

@@ -14,7 +14,7 @@ INCDIR=$(ROOT)/include
 
 WARNFLAGS+=
 EXTRA_CFLAGS=
-EXTRA_CXXFLAGS=
+EXTRA_CXXFLAGS=-Wno-deprecated-enum-enum-conversion
 
 # Set to 1 to enable hot/cold linking
 USE_PACKAGE:=1

common.mk

@@ -34,7 +34,7 @@ LIBRARIES+=$(wildcard $(FWDIR)/*.a)
 EXCLUDE_COLD_LIBRARIES+=$(FWDIR)/libc.a $(FWDIR)/libm.a
 COLD_LIBRARIES=$(filter-out $(EXCLUDE_COLD_LIBRARIES), $(LIBRARIES))
 wlprefix=-Wl,$(subst $(SPACE),$(COMMA),$1)
-LNK_FLAGS=--gc-sections --start-group $(strip $(LIBRARIES)) -lgcc -lstdc++ --end-group -T$(FWDIR)/v5-common.ld
+LNK_FLAGS=--gc-sections --start-group $(strip $(LIBRARIES)) -lgcc -lstdc++ --end-group -T$(FWDIR)/v5-common.ld --no-warn-rwx-segments
 
 ASMFLAGS=$(MFLAGS) $(WARNFLAGS)
 CFLAGS=$(MFLAGS) $(CPPFLAGS) $(WARNFLAGS) $(GCCFLAGS) --std=$(C_STANDARD)

include/abstractGlobals.hpp

@@ -12,10 +12,9 @@ extern rd_view_t *allianceview;
 extern rd::Selector gui_selector;
 void rdconfig_init();
 
-extern bool isCompetition;
 extern std::string alliance;
-extern std::string auton_name;
 extern std::string field_status;
+extern void competitionTelemtryRefresh();
 
 /* Functions */
 // DT

include/deviceGlobals.hpp

@@ -11,11 +11,11 @@ inline pros::Controller controller(pros::E_CONTROLLER_MASTER);
 // inline pros::MotorGroup rightDrive({-12, 13, -17});
 
 // v1
-inline pros::MotorGroup leftDrive({-1, -2, 3});
-inline pros::MotorGroup rightDrive({6, -7, 8});
+inline pros::MotorGroup leftDrive({-18, 19, 20});
+inline pros::MotorGroup rightDrive({-11, 12, 13});
 
 // Intake
-inline pros::Motor intake(-10);
+inline pros::Motor intake(-14);
 inline pros::MotorGroup wallStake({-13, 14});
 
 // Pneumatics
@@ -26,23 +26,23 @@ inline pros::adi::Pneumatics doinkerPiston('B', false);
 inline pros::Optical optical(14);
 inline pros::Imu inertial1(17);
 inline pros::Imu inertial2(15);
-inline pros::Rotation wallStakeSensor(12);
+inline pros::Rotation wallStakeRotationSensor(12);
 
 inline pros::Rotation verticalEncoder(4);
 inline pros::Rotation horizontalEncoder(-5);
 //hello world it is 210K secret note iykyk :D
 // horizontal tracking wheel
-inline lemlib::TrackingWheel vertical_tracking_wheel(&verticalEncoder, lemlib::Omniwheel::NEW_2, 0.44);
+inline lemlib::TrackingWheel vertical_tracking_wheel(&verticalEncoder, lemlib::Omniwheel::NEW_275, 0.44);
 // vertical tracking wheel
-inline lemlib::TrackingWheel horizontal_tracking_wheel(&horizontalEncoder, lemlib::Omniwheel::NEW_2, 1.65);
+inline lemlib::TrackingWheel horizontal_tracking_wheel(&horizontalEncoder, lemlib::Omniwheel::NEW_275, 1.65);
 
 // drivetrain settings
 inline lemlib::Drivetrain drivetrain(&leftDrive, // left motor group
                               &rightDrive, // right motor group
                               13.5, // track width
                               lemlib::Omniwheel::NEW_325,
-                              360, // drivetrain rpm
-                              2 // chase power is 2. If we had traction wheels, it would have been 8
+                              450, // drivetrain rpm
+                              8 // chase power is 2. If we had traction wheels, it would have been 8
 );
 // lateral motion controller
 inline lemlib::ControllerSettings lateralController(10, // proportional gain (kP)

include/libKS/drivetrain/odom.hpp

@@ -11,7 +11,7 @@ namespace ks
 
     extern Position odom_pos;
 
-    extern void odomThread();
+    extern void odomUpdate();
     extern void setOdomPosition(double x_new, double y_new, double theta_new);
     extern void initializeOdom();
     extern pros::Task odom_task;

include/libKS/utilities.hpp

@@ -5,99 +5,139 @@
 #include <numeric>  // for std::accumulate
 #include <algorithm>
 #include <deque>
+#include <cmath>
 
 namespace ks
 {
-    inline double vector_average(const std::vector<double>& v) {
-        return std::accumulate(v.begin(), v.end(), 0.0) / v.size();
-    }
-    inline double median_filter(std::deque<double>& buffer, double newVal, int windowSize) {
-    	buffer.push_back(newVal);
-    	if (buffer.size() > windowSize) {
-    	    buffer.pop_front();
-    	}
-
-    	std::vector<double> data(buffer.begin(), buffer.end());
-    	std::sort(data.begin(), data.end());
-
-    	return data[windowSize / 2];
-    }
-    // prolly dont use this 💀
-    inline double tripleIMUHeading(double heading1, double heading2, double heading3, double threshold) { 
-    	// Run through median filter
-        int windowSize = 20;
-    	std::deque<double> buffer1;
-    	std::deque<double> buffer2;
-    	std::deque<double> buffer3;
-    	heading1 = ks::median_filter(buffer1, heading1, windowSize);
-    	heading2 = ks::median_filter(buffer2, heading2, windowSize);
-    	heading3 = ks::median_filter(buffer3, heading3, windowSize);
-        // Calculate the absolute differences between the headings
-        double diff12 = std::abs(heading1 - heading2);
-        double diff23 = std::abs(heading2 - heading3);
-        double diff13 = std::abs(heading1 - heading3);
-        // Check if one of the sensors is drifting
-        if (diff12 > threshold && diff13 > threshold) {
-            // Sensor 1 is drifting, return mean of sensor 2 and 3
-            return (heading2 + heading3) / 2.0;
-        } else if (diff12 > threshold && diff23 > threshold) {
-            // Sensor 2 is drifting, return mean of sensor 1 and 3
-            return (heading1 + heading3) / 2.0;
-        } else if (diff23 > threshold && diff13 > threshold) {
-            // Sensor 3 is drifting, return mean of sensor 1 and 2
-            return (heading1 + heading2) / 2.0;
-        } else {
-            // No sensor is drifting, return mean of all sensors 
-    		// (or all of them are drifing and we just gotta pray 💀)
-            return (heading1 + heading2 + heading3) / 3.0;
-        }
-    }
-    inline bool isDriverControl() {
-    	return pros::competition::is_connected() && !pros::competition::is_autonomous() && !pros::competition::is_disabled();
-    }
-    inline float reduce_0_to_360(float angle) {
-      while(!(angle >= 0 && angle < 360)) {
-        if( angle < 0 ) { angle += 360; }
-        if(angle >= 360) { angle -= 360; }
-      }
-      return(angle);
-    }
-    inline float reduce_negative_180_to_180(float angle) {
-      while(!(angle >= -180 && angle < 180)) {
-        if( angle < -180 ) { angle += 360; }
-        if(angle >= 180) { angle -= 360; }
-      }
-      return(angle);
-    }
-    inline float reduce_negative_90_to_90(float angle) {
-      while(!(angle >= -90 && angle < 90)) {
-        if( angle < -90 ) { angle += 180; }
-        if(angle >= 90) { angle -= 180; }
-      }
-      return(angle);
-    }
-    inline double to_rad(double angle_deg){
-      return(angle_deg/(180.0/M_PI));
-    }
-    inline double to_deg(double angle_rad){
-      return(angle_rad*(180.0/M_PI));
-    }
-    inline float clamp(float input, float min, float max){
-      if( input > max ){ return(max); }
-      if(input < min){ return(min); }
-      return(input);
-    }
-    inline bool isReversed(double input){
-      if(input<0) return(true);
-      return(false);
-    }
-    inline float to_milivolt(float input){
+	inline double vector_average(const std::vector<double>& v) {
+	    return std::accumulate(v.begin(), v.end(), 0.0) / v.size();
+	}
+
+	inline double median_filter(std::deque<double>& buffer, double newVal, int windowSize) {
+		buffer.push_back(newVal);
+		if (buffer.size() > windowSize) {
+		    buffer.pop_front();
+		}  	
+		std::vector<double> data(buffer.begin(), buffer.end());
+		std::sort(data.begin(), data.end());   	
+		return data[windowSize / 2];
+	}
+
+	// prolly dont use this 💀
+	inline double tripleIMUHeading(double heading1, double heading2, double heading3, double threshold) { 
+		// Run through median filter
+	    int windowSize = 20;
+		std::deque<double> buffer1;
+		std::deque<double> buffer2;
+		std::deque<double> buffer3;
+		heading1 = ks::median_filter(buffer1, heading1, windowSize);
+		heading2 = ks::median_filter(buffer2, heading2, windowSize);
+		heading3 = ks::median_filter(buffer3, heading3, windowSize);
+	    // Calculate the absolute differences between the headings
+	    double diff12 = std::abs(heading1 - heading2);
+	    double diff23 = std::abs(heading2 - heading3);
+	    double diff13 = std::abs(heading1 - heading3);
+	    // Check if one of the sensors is drifting
+	    if (diff12 > threshold && diff13 > threshold) {
+	        // Sensor 1 is drifting, return mean of sensor 2 and 3
+	        return (heading2 + heading3) / 2.0;
+	    } else if (diff12 > threshold && diff23 > threshold) {
+	        // Sensor 2 is drifting, return mean of sensor 1 and 3
+	        return (heading1 + heading3) / 2.0;
+	    } else if (diff23 > threshold && diff13 > threshold) {
+	        // Sensor 3 is drifting, return mean of sensor 1 and 2
+	        return (heading1 + heading2) / 2.0;
+	    } else {
+	        // No sensor is drifting, return mean of all sensors 
+			// (or all of them are drifing and we just gotta pray 💀)
+	        return (heading1 + heading2 + heading3) / 3.0;
+	    }
+	}
+
+	inline bool isDriverControl() {
+		return pros::competition::is_connected() && !pros::competition::is_autonomous() && !pros::competition::is_disabled();
+	}
+
+	inline double reduce_0_to_360(double angle) {
+	  while(!(angle >= 0 && angle < 360)) {
+	    if( angle < 0 ) { angle += 360; }
+	    if(angle >= 360) { angle -= 360; }
+	  }
+	  return(angle);
+	}
+
+	inline double reduce_negative_180_to_180(double angle) {
+	  while(!(angle >= -180 && angle < 180)) {
+	    if( angle < -180 ) { angle += 360; }
+	    if(angle >= 180) { angle -= 360; }
+	  }
+	  return(angle);
+	}
+
+	inline double reduce_negative_90_to_90(double angle) {
+	  while(!(angle >= -90 && angle < 90)) {
+	    if( angle < -90 ) { angle += 180; }
+	    if(angle >= 90) { angle -= 180; }
+	  }
+	  return(angle);
+	}
+
+	inline double to_rad(double angle_deg){
+	  return(angle_deg/(180.0/M_PI));
+	}
+
+	inline double to_deg(double angle_rad){
+	  return(angle_rad*(180.0/M_PI));
+	}
+
+	inline double clamp(double input, double min, double max){
+	  if( input > max ){ return(max); }
+	  if(input < min){ return(min); }
+	  return(input);
+	}
+
+	inline bool isReversed(double input){
+	  if(input<0) return(true);
+	  return(false);
+	}
+
+  inline float to_milivolt(float input){
       return(input * (12000.0/127.0));
-    }
-    inline float deadband(float input, float width){
-      if (fabs(input)<width){
-        return(0);
-      }
-      return(input);
-    }
+  }
+
+	class PID {
+	    public:
+	    // Constructor
+	    PID(double kP, double kI, double kD) 
+	    : kP(kP), 
+	      kI(kI), 
+	      kD(kD) {}
+
+	    // Member function to update PID
+	    double update(const double error) {
+	        // calculate integral
+	        integral += error;
+
+	        // calculate derivative
+	        const double derivative = error - prevError;
+	        prevError = error;
+
+	        // calculate output
+	        return error * kP + integral * kI + derivative * kD;
+	    }
+
+	    // Member function to reset PID
+	    void reset() {
+	        integral = 0;
+	        prevError = 0;
+	    }
+
+	    protected:
+	    // Member variables
+	    double kP;
+	    double kI;
+	    double kD;
+	    double integral = 0;
+	    double prevError = 0;
+	};
 }

include/robodash/api.h

@@ -9,8 +9,8 @@
 
 #define ROBODASH
 #define RD_VERSION_MAJOR 2
-#define RD_VERSION_MINOR 1
-#define RD_VERSION_PATCH 1
+#define RD_VERSION_MINOR 2
+#define RD_VERSION_PATCH 0
 
 #include "liblvgl/lvgl.h"
 

include/robodash/views/image.hpp

@@ -53,6 +53,14 @@ class Image {
 	 */
 	Image(lv_img_dsc_t *image_dsc, std::string name = "Image");
 
+	/**
+	 * @brief Create a new Image
+	 *
+	 * @param image_dsc Pointer to constant LVGL image descriptor object
+	 * @param name Name to display on screen
+	 */
+	Image(const lv_img_dsc_t *image_dsc, std::string name = "Image");
+
 	/**
 	 * @brief Set this view to the active view
 	 */