Overture 7421 | Build Blog 2024 | Open Alliance

Welcome to Overture’s 2024 build thread! :purple_circle:

Overture is thrilled to join the Open Alliance for the upcoming 2024 season!

We are team 7421, a FIRST Robotics Competition team from Monterrey, Mexico. We started competing in the 2019 season with approximately 35 team members and 5 years later, there are over 50 students and 10 mentors involved in the project.

Through our “Assembling leaders” vision, we have spread an interest in the field of science and technology within our team and our community. Overture’s mission is about creating independent students who also are leaders of change and inspire those around them. We look to become role models for other teams by making mistakes, putting on our trial and error, and ensuring the students learn from this process. This is how we’ll become changemakers for the future of STEAM education in Mexico.

2024 Overture Season Resources

Our 2023 Season Highlights

2023 Season Recap

For the 2023 season, we decided to create an arm with two degrees of freedom, something we had never done before! What did we learn from all this? Building an arm is time-consuming and more complicated than we initially thought.

This is Miura, our robot for the 2023 season: Charged Up.

A bit of Miura in the field.

The challenge? Figuring out how to do it before week one events and not dying in the process. Did we succeed?

"Yes… but not in the timeframe we would have liked.”

To better control the double-jointed arm, we initially used our custom kinematics class at regional events. However, the joints’ movements weren’t consistently smooth or fast enough. After the season, we switched to the TalonFX Motion Magic, which improved joint speed and control.

2023 Off-Season Projects (Mechanical / Programming)

  • For the OffSeason, we decided to build another robot with a mechanism we had never attempted before as part of our preparation for this upcoming season. What did we choose? An elevator…more precisely, an elevator similar to the one used by team 1678, but adapted to our resources and limitations.

    This is Mauro, who participated in this 2023 OffSeason Mexico-All Star and The Remix.

  • Auto

  • We also decided to renovate our Driver Station and “OverMaquina” (where we transport the robot).

Here are some photos and the CAD for each.

:video_game: Driver Station

:purple_square: OverMaquina

2023 Off-Season Project Community

  • 2023 Purple Camp - We hosted two weeks of fun, innovation, science, and technology, where 42 children aged 8 to 14 had the opportunity to learn about FIRST.

  • Overture Kids School Program Update - A program that we have been running for our third year. We visit a school where we give classes using LEGO, organize general knowledge tournaments, math tournaments, and a book drive and donation. This cycle concluded with a holiday celebration after a total of 7 visits to the school, impacting 250 children.

  • OverVlogs - Our Youtube videos for the community and other teams to watch, we’ve uploaded 3 vlogs that reached 3K views, and two more are currently in editing. This season, the plan is to continue with these OverVlogs.

  • OverTraining - This is our third year mentoring other FRC teams, we consistently support 4 teams in areas such as Programming, Mechanics, Business, and Marketing, all while assisting with their competition registrations, as well as coordinating travel plans with them.

  • FTC Team 23619 - After 5 years, we opened our first FTC team to serve as an education bridge from FLL to FRC. Team 23619 is in its rookie season for Centerstage and will compete in February in the Monterrey Regional.

  • Co-hosted the first Official Mexican OffSeason: Mexico All-Star - For the first time in 20 years, the first OffSeason event in Mexico was registered and successfully executed. We had the opportunity to support logistics and assist in running the event. We hosted 35 teams, participated in the competition, and volunteered.

Software Organization Update - 2023

  • Miura Robot Code & Mauro Robot Code (Off Season)
  • During the 2023 OffSeason, we began crafting an in-house library to speed up our code development for next year. It handles motor and encoder declarations, along with our core swerve code. The library is still a work in progress and might change a lot before the next season begins as it’s starting to look more like a codebase than a library.
  • For the 2024 season, we planned to switch from C++ to Java because we started an FTC team. Initially, we wanted language consistency across teams, but due to time constraints, we decided to postpone the switch until after the 2024 Houston Championship.
19 Likes

Week 1 Update

Kick Off

  • We went to the Kick Off at Prepa Tec Santa Catarina with the team to see this year’s challenge. After finishing the broadcast, we returned to our workshop to read the manual and complete the rule quiz of 1678.
  • Once the quiz was completed, the whole team gathered to simulate matches. We ran simulations of autonomous actions and game scenarios to get an idea of how the game could unfold.

Autonomous Mock

Match Mock

Highlights

  • Scoring the highest number of notes in the autonomous phase is crucial to earning the ranking point for notes.
  • Going under the stage will be essential to avoid traffic and shorten the paths for autonomous actions.
  • Notes in the center of the field will be highly contested, similar to cans in the 2015 Recycle Rush.
  • The ability to shoot notes from a distance is necessary to complete cycles more quickly.

Autonomous Ideas

After the game simulations, we reached the conclusion that the notes in the center will be crucial to maximize points. We have decided on the following three autonomous routines as a starting point to begin optimizing the robot’s paths.

Prototypes

We started prototyping our shooter using two PVC rollers covered with insulation tape and tennis racket grip tape. These prototype seemed to be pretty consistent if the note was fed in the same angle. We have more videos of our prototype testing in our Youtube playlist.

Shooter prototype CAD here.

We also tested for maximum distance and the prototype is capable of shooting from half court, but we are not planning on doing that for now.

For our intake we tested a simple feeder with compliant wheels which seemed to be fast and consistent.

Krayon CAD

  • Our initial idea was inspired by the RI3D Unqualified Quokkas’ robot, which had the shooter and intake in the same articulated mechanism. After several iterations, we decided that separating these two mechanisms would be more suitable for us. This decision was influenced by the movement restrictions that were being introduced to fulfill both purposes with the same mechanism.

To score in the trap, we considered climbing with the arm that moves the entire shooter and performing a handoff of the chain to the chassis. This would free up the arm to facilitate engagement with the trap. Additionally, we plan to add rear supports to ensure the most stable ascent possible.

Software

During the week the software team started by creating our 2024 repository and updating our codebase with latest vendor dependencies releases. And for the first time we are trying to use simulation using our Krayon CAD models, we are still working on it, will post an update on the next week update.

We also started testing the new Photonvision release to find the highest resolution we could use without losing performance and accuracy.

12 Likes

Alpha Bot

Started building our alpha bot by attaching our intake prototype to our swerve drive base. The under-the-bumper intake, inspired by teams 95, 3847, and 4522, seems to be able to intake the notes at high speeds.

The CAD is almost finished and ready to be put into our simulator. We will be posting pictures of the CAD and videos of the simulation later today.

Field

Finally, we finished building our field elements using leftover wood and polycarbonate for the Source, Amp, and Speaker. The Stage was built after buying the chain and some PVC pipes.

AMP

Speaker

Source

Stage

8 Likes

Alpha Bot and Simulation

The software team finished importing the CAD of the Alpha Bot into the simulator and started testing it with some basic commands. We hope that by Monday, we can begin testing the autos in the simulator. We aim to finish building alpha version of the robot this weekend.

We didn’t have time to record videos of the simulation, but the robot has already been imported.

Here’s an image of our current concept, Alpha Bot, It consists of an under-the-bumper intake and a shooter attached to a double-jointed arm. The climbing mechanism is still missing, but it should be done in a day or two.

10 Likes

Simulation and Vision

Our simulation is almost completely ready to test our robot, we were able to incorporate mechanisms weight, reduction and other variables to be able to replicate as close as possible our robot behavior’s, we could also get close enough PID and Motion Magic values for the motion of the mechanisms. Using our OvertureLib and CTRE simulation capabilities we were able to incorporate simulation into our codebase with minimal changes to the CTRE devices wrappers we had.

Also managed to incorporate cameras with Photonvision on the simulator for April Tag detection with the full field on the sim. With all these additions we might be able to have a almost fully coded robot by the end of the month as we will be able to test autonomous and robot commands.

Also currently working on a post on characterization with the new SysID updates and C++ coming tomorrow today.

14 Likes

Characterization

The 2024 WPILib brought a lot of changes to robot characterization, for us these changes helped and simplified the process for us as our old code for characterization for swerve drive was broken and we didn’t have the time to fix it up. As mentioned in and earlier post having our own Library/Codebase helped us implement the new changes simply by following the SysId examples and with minimal changes to the code. Here is a brief and hopefully helpful explanation on how we implemented it on our C++ code.

First the SwerveModule class was modified to add any methods missing for logging. We were missing a method for getting back the voltage provided to the motor and one method to give the drive motors raw voltage instead of the voltage provided by our FeedForward object.

double getDistance();
double getAngle();
double getVoltage();

frc::SwerveModuleState getState();
void setState(frc::SwerveModuleState state);
frc::SwerveModulePosition getPosition();

void setRawVoltageSpeed(units::volt_t volts);

The setRawVoltageSpeed method was set up also keep the wheels facing forward.

/**
 * @brief Gets the voltage of the module
 * 
 * @return - Voltage of the module
*/
double SwerveModule::getVoltage(){
	return m_driveMotor->GetMotorVoltage().GetValueAsDouble();
}

/**
 * @brief Sets the raw voltage speed
 * 
 * @param volts - Voltage
*/
void SwerveModule::setRawVoltageSpeed(units::volt_t volts) {
	m_driveMotor->setVoltage(volts, false);

	m_turningMotor->setPositionVoltage(0, false);
}

On the SwerveChassis subsystem we added a method called sysIdVoltage that would pass the voltage provided to all 4 swerve modules.

public:
void sysIdVoltage(units::volt_t voltage);
/**
 * @brief Sets the voltage for the SysId command
*/
void SwerveChassis::sysIdVoltage(units::volt_t voltage) {
	frontLeftModule->setRawVoltageSpeed(voltage);
	frontRightModule->setRawVoltageSpeed(voltage);
	backLeftModule->setRawVoltageSpeed(voltage);
	backRightModule->setRawVoltageSpeed(voltage);

}

After that we imported and instantiated the new SysIdRoutine Object to the SwerveChassis subsystem, we then modified the code from the example to log the each of the driving motors in our swerve drive.

Then created the Quadstatic and Dynamic methods as Commands to map them out to a xbox controller object.

public:
frc2::CommandPtr SysIdQuadstatic(frc2::sysid::Direction direction);
frc2::CommandPtr SysIdDynamic(frc2::sysid::Direction direction);

private:
frc2::sysid::SysIdRoutine m_sysIdRoutine{
		  frc2::sysid::Config{std::nullopt, std::nullopt, std::nullopt,
							  std::nullopt},
		  frc2::sysid::Mechanism{
			  [this](units::volt_t driveVoltage) {
				sysIdVoltage(driveVoltage);
			  },
			  [this](frc::sysid::SysIdRoutineLog* log) {
				log->Motor("frontRight")
					.voltage(units::volt_t{frontRightModule->getVoltage()})
					.position(units::meter_t{frontRightModule->getDistance()})
					.velocity(units::meters_per_second_t{frontRightModule->getSpeed()});
				log->Motor("frontLeft")
					.voltage(units::volt_t{frontLeftModule->getVoltage()})
					.position(units::meter_t{frontLeftModule->getDistance()})
					.velocity(units::meters_per_second_t{frontLeftModule->getSpeed()});
				log->Motor("backRight")
					.voltage(units::volt_t{backRightModule->getVoltage()})
					.position(units::meter_t{backRightModule->getDistance()})
					.velocity(units::meters_per_second_t{backRightModule->getSpeed()});
				log->Motor("backLeft")
					.voltage(units::volt_t{backLeftModule->getVoltage()})
					.position(units::meter_t{backLeftModule->getDistance()})
					.velocity(units::meters_per_second_t{backLeftModule->getSpeed()});
			  },
			  this} };

For the commands we had to put them in a sequence command to make the wheels line up before starting to prevent the robot from going sideways or rotating.

/**
 * @brief Runs the SysId Quasisstatic command
*/
frc2::CommandPtr SwerveChassis::SysIdQuadstatic(frc2::sysid::Direction direction) {
	return frc2::cmd::Sequence(
		frc2::InstantCommand([this]() { sysIdVoltage(0_V); }).ToPtr(),
		frc2::cmd::Wait(0.5_s),
		m_sysIdRoutine.Quasistatic(direction)
	);
}

/**
 * @brief Runs the SysId Dynamic command
*/
frc2::CommandPtr SwerveChassis::SysIdDinamic(frc2::sysid::Direction direction) {
	return frc2::cmd::Sequence(
		frc2::InstantCommand([this]() { sysIdVoltage(0_V); }).ToPtr(),
		frc2::cmd::Wait(0.5_s),
		m_sysIdRoutine.Dynamic(direction)
	);
}

For running the tests we created a new RobotContainer where we created another instance of our Chassis and CommandXboxController object and mapped out the commands to the A, B, X and Y buttons. These files were almost a copy from the SysId example and minimal changes were needed to make it work with our bot.

#pragma once

#include <frc2/command/CommandPtr.h>
#include <frc2/command/button/CommandXboxController.h>

#include "../Subsystems/Chassis/Chassis.h"

#include "OvertureLib/Commands/Drive/Drive.h"

class SysIDRoutineBot {
 public:
  SysIDRoutineBot();

  frc2::CommandPtr GetAutonomousCommand();

private:
  void ConfigureBindings();
  frc2::CommandXboxController m_driverController{ 0 };
  Chassis m_drive;

};
#include "SysIDRoutineBot.h"

#include <frc2/command/Commands.h>

SysIDRoutineBot::SysIDRoutineBot() {
    ConfigureBindings();
}

void SysIDRoutineBot::ConfigureBindings() {
    m_drive.SetDefaultCommand(Drive{&m_drive, &m_driverController});

    m_driverController.A().WhileTrue(
        m_drive.SysIdQuadstatic(frc2::sysid::Direction::kForward));
    m_driverController.B().WhileTrue(
        m_drive.SysIdQuadstatic(frc2::sysid::Direction::kReverse));
    m_driverController.X().WhileTrue(
        m_drive.SysIdDinamic(frc2::sysid::Direction::kForward));
    m_driverController.Y().WhileTrue(
        m_drive.SysIdDinamic(frc2::sysid::Direction::kReverse));
}

frc2::CommandPtr SysIDRoutineBot::GetAutonomousCommand() {
    return m_drive.Run([] {});
}

At the end we ran all the tests and uploaded the WPILogs to a computer using the driver station and followed the loading data guide from the docs.

After getting our new values we just added them to our swerve modules and deployed them to the our bot.

frontLeft.setFFConstants(0.15117_V, 1.9912_V, 0.032941_V);
frontRight.setFFConstants(0.11106_V, 2.0075_V, 0.08823_V);
backLeft.setFFConstants(0.030111_V, 2.0732_V, 0.16158_V);
backRight.setFFConstants(0.09324_V, 2.0492_V, 0.077588_V);
11 Likes

Alpha Bot

After some testing we decided to stop building our Alpha Bot. The decision was made due to time and budget constraints (we competed in week 1). Starting today, we will focus on completing the CAD of the final robot. We managed to conduct some tests with the intake, shooter, and storage yesterday before disabling the robot. Through these tests, we realized that our storage cannot contain the note in place, so we decided to add an additional 0.5 inches of compression on the sides. Our shooter and intake were pretty consistent and we are not planning on changing anything major. Here are some videos from the alpha bot tests from yesterday.

Storage Fail

Successful shots.
The rollers in the shooter are attached to a Falcon motor each with a 1:3, the shooter was tested with the motors running at 4 volts each

Software updates

  • This week we plan on using PathPlanner’s pathfinding capabilities and April Tag detection to help the drivers line up for the climbing.

  • Simulation is almost ready, software team is waiting for the final CAD to import it.

  • Started working on updating our April Tag detection base code. Last week we updated the code to use the blue alliance origin coordinates for our odometry correction, the reasoning for the change was that Pathplanners handles autos for both alliances using the origin coordinates from the blue side.

3D Printing

Since the 2022 we have started to rely heavily on 3D printing parts, which became one of the most important part of our design process. Our current set up consists of 4 Creality printers, a Ender 3, Ender 3 v2 Neo, S1 and a recently acquired S1 Pro. Most of our printers are mentor owned with the exception of the S1 which was a donation. The Ender 3 V2 Neo is currently getting repairs.

At first we started only printing spacers and some 2 inch mecanum wheels, but since the 2023 season we started experimenting with printing gears on PLA, which were fine for uses where the printed part was not under a lot of stress or force.

In the 2023 offseason we started experimenting with PETG and actually printed our elevator stoppers, pulleys and the intake gearbox cover for our 1678 clone bot with it, none of the printed parts broke during our 2 offseason competitions.

With the new S1 Pro and a Creality Sonic Pad we are conducting testing on Polycarbonate filament pulleys and we are waiting on the arrival of some Nylon filament for testing 3D printed gears.

9 Likes

Impressive job. Congrats! I do have one question though. Why did you chose to use Gazebo for simulation, instead of tools such as AdvantageScope which are easy to implement? Knowing the huge number of applications, I would assume there are many tools that are useful for simulation, though I don’t know the cost of it. Did you create wrappers for connecting WPILIB code to gazebo? Or are you writing your code in ROS?

Aside from that, what’s this year robot’s name going to be :eyes:?

5 Likes

Hello, I’m the mentor that worked on Gazebo to simulate the robot’s code. We are indeed using ROS for the project. The main reason to use Gazebo is not really that technical, I had always wanted to use it for an FRC robot since I joined FIRST.

Also, looking into AdvantageScope it mostly works as a NT and logs visualizer, which needs the simulation be done in the WPILib project. We are currently running the simulation within Gazebo and sending that to the robot’s code using NT, and some wrappers we did that utilize the simulation implementations for CTRE and WPILib classes. No comment regarding the robot’s name :dotted_line_face:

9 Likes

Mini Update

Climbing Command

We wanted to simplify the climbing procedure for the driver by developing a semi automated climbing command using PathPlanner path finding and april tag detection.

Using PathPlanner we created a path for each side of the stage and based on the robot odometry it will look for the closest path for the bot to follow and then start the climbing procedure.

11 Likes

Wow, I’m really loving your design so far, it looks very effective, and I love the simulation videos - gave me a few ideas for our robot. Will definitely be keeping an eye on you guys this year. Much love from New Jersey, (and a fellow Mexican from afar).

Viva México! :mexico:

9 Likes

Weekend Recap

CAD and robot updates

Over the weekend the mechanics team worked on finishing the competition robot CAD.

We also started cutting some aluminum plates for our competition robot with the assistance of CNC machines from our friends at 6017 and 6647. We are hoping to start construction of our bot this Monday to have it ready for week 1.




Our new robot cart and driver station are also done and ready for competition.


Climbing Simulation (Yes, again)

Our semi autonomous climbing and scoring on trap sequence is basically almost done, there are just a couple of timing issues left to fix, but April Tag detection, Pathplanner’s pathfinding and our commands seem to be working excellent together.

Note: For now chain physics and collisions are not enabled on the simulation as it might break some of the robot physics.

Autonomous

This Monday we will be continuing with our 3 autonomous base routines. Our autonomous strategy has not changed that much since the first week after kick off. For now, we will continue using as a base the autonomous routines that we mentioned in our Week 1 post.

I’m going to write a post with more details about each of our autonomous routines during the week to explain the reasoning behind each one.

15 Likes

Tuesday Update

Today we have a small post, we had a slow day yesterday as we were waiting on some parts to arrive and software is still busy getting some commands ready for autonomous testing. (Post on autos coming later this week.)

Building the Bot

We finally got our orders from the vendors and some of our aluminum plates, so today we began building our competition bot.

As always our robots need to be purple, so obviously the first step of building was painting the extrusions with spray paint from the local paint store.

Meanwhile the software team managed to test some LED for robot feedback and communication on the chassis of the alpha bot.

After testing the LEDs we started disassembling our Alpha Bot chassis to give our swerve modules some maintenance before using them on the competition chassis.

10 Likes

Thursday Update

Small Shooter CAD Change

As many other teams have mentioned on their build blogs we decided to cut our PVC rollers in the middle and only keep them on the sides to prevent the note from deforming into an oval. We were not able to test the consistency of the shot without the center of the rollers, but we bought enough PVC tube to change between them once the robot is built. The plan is to print the PVC to HEX adapters on polycarbonate filament for its thermal resistance properties and to add infrared sensors for game piece detection.

Building

This last couple days the build team has been building all of the mechanisms and new chassis, while the construction is still on early phases we expect to finish building the robot next week so our drivers have time to practice before our next competition. Here are some pictures showcasing our build progress.

The chassis is almost done, software/electrical team should begin wiring and placing devices in the next couple of days.

The build team just started building the intake and shooter but should be catching up with the other mechanisms shortly.

The first joint is almost finished and should be done in the next couple days. I don’t remember if we mentioned it before, but we settled in a double jointed mechanism that should be capable of climbing, scoring on the amp, speaker and trap. Even after seeing a lot of teams using a single joint and elevator/telescope combination we believe that our experience during the 2023 season with multiple joints will allows to built a faster and more consistent mechanism than if we used another of the previously mentioned combination.

Our climbing support arms are almost half way built also, we are also waiting on printing our encoders gears.

Vision

Since our Arducam OV9281 broke we tried buying another one but the USB version seems to be discontinued, we are looking for alternatives or considering buying the 2MP (OV2311) version that is still being sold.

Automating Telop Tasks

Inspired by the many teams, especially team 6328, that have started automating their teleoperated commands or routines the software team decided to try and automate many of the tasks that our drivers have to do through a match, while also keeping a manual version.

To automate our task, as mentioned on one of our previous post, we have been using pathplanner’s pathfinding and On the fly generator for the automation.

Overture Lib updates

  • Implemented a logging library which will be adapted to a WPILib Subsystem wrapper in our Overture Lib. Probably going to make a more detailed post on this later on the season.

  • Started discussing the idea of creating our own vendordep, still discussing the idea but probably would be a offseason.

  • Also for the offseason we are planning on a big refactoring as it has started to grow more than we actually expected.

  • Thinking of adding game piece detection vision again if we have the time to implement it, more probably for our second event.

11 Likes

Friday Update

Build Progress Updates

A small update on our build progress, bigger update coming this weekend.



10 Likes

Autonomous

This year we had a goal of having at least three consistent autos for our week 1, to achieve this we decided to keep using and taking advantage of all of PathPlanner’s capabilities. On our week one post we briefly talked about our three base autos. As of Week 4 we decided that making an alternate auto for each one would help us have more compatibility with alliances in qualifications, without having too many routines to worry about,

3 Note Wing Auto

For the first auto we are planning on at least scoring the 3 notes located on the wing, while also having an alternative that will be able to score 5 Notes, hopefully 6. We are currently working on a shooting while moving code that should help achieve the 5 Note version of this auto.

Left Side and Right Side Auto

For this two autos the plan is to shoot the preloaded note and go straight for the centerline notes on each side. Both of them should be able to shoot 3 notes while leaving the one in the center alone. We hope that with some tunning we could make an alternate auto for both that also shoots the center note.

Robot Progress Pictures

Robot is almost done we are just working on the final assembling steps and waiting on some printed polycarbonate parts to be done.



9 Likes

Wednesday Small Update

We have just a small update today. Probably will be posting a working bot video in a day or two.

Robot

We are in the final stages of wiring and building our competition bot. Still waiting on some PETG spacers and PC adapters for our shooter to finish printing.

Software

  • Still working on our base autos, we have yet to test them in simulation but should be almost ready to run on the real robot, we hope that we should only need to make some adjustments to PIDs and some positions to get them to the minimum acceptable version. Once the robot is ready we will start perfecting them as simulation can only take us so far.
  • Finished Shooting While Moving code, which seems to be working correctly on simulation we only need to adjust our interpolation tables and some PID values once we test it on the real bot.
  • Finished making semi-autonomous versions of most our scoring commands. Again simulation seems to work great and should only need minor values adjustment once in a non simulated environment.
  • We finally ordered a replacement camera, while we couldn’t get a OV9281 replacement we got a AR0114 that should work fairly similar. While we wait for it to arrive we will be testing vision with the broken OV928, which seems to work some times.
7 Likes

Friday Update

It’s alive (almost)

No video today as we were not able to record anything before we started disassembling it for some semi-major changes to our storage/shooter subsystem. But our arm is already working and moving, will be uploading some videos of it working tomorrow.

Storage changes

Today we tried testing our storage but found that our current storage configuration is not working so we are changing it to a roller storage with only top rollers because of space constraints and print centering parts for our intake. Changes should be done by tomorrow.

Before

After

There are a couple of things missing, like the motor mount, but is mostly finished.

12 Likes

Saturday

Intake

While part of the team was building the new storage/shooter the rest of team was testing the competition intake. We were using compliance wheels and PETG spacers for intaking the notes. The wheels were compressing the note too much and the motor was stalling, also the wheels with spacers were vibrating a lot, so we decided to change the 2 bottom rollers to PVC rollers with grip tape with a 1.3 inch diameter. The new rollers fixed our compression issue and we are currently working on replacing the rest of the compliance wheels with different diameter PVCs to prevent any further issues.

7 Likes

Tuesday Update

It’s Alive (For real this time)

Intake and storage changes are finally done and software team has been working on characterizing the mechanisms and swerve the last couple of days. Mechanically we are just working on some weight reduction on our intake.

Most of our code seems to be working correctly and we are just working on fine tuning shooting while moving and some interpolation tables.

Here are some videos of some robot testing and tuning, the final code should allow the robot to be faster than what’s shown in the current videos.

Intake and Amp Scoring

Shooting interpolation testing

7 Likes