FRC 8088 Bionic Panthers | 2024 Build Thread | Open Alliance

The Liberty Hill Bionic Panthers Team 8088 are excited to announce our joining to Open Alliance officially!

Who Are We?

Our team is based out of Liberty Hill High School, in Liberty Hill, Texas. The team started in 2016 (with BEST Robotics Team #0463), but added an FRC team in 2020’s Infinite Recharge. Over the years, we’ve gone on towards expanding our program in FRC and BEST, with more community outreach and FRC team collaborations!

Right now our team consists of 36 students and 7 FRC mentors. The team is split into 7 different sub-teams as shown below. The team has a Project Manager and each sub-team has a corresponding sub-team Manager.

What to expect from us:

  • Weekly Recaps from all subteams
  • Training Materials we used this fall
  • Testing Videos
  • Failures
  • Lessons Learned
  • Event Recaps

Our Last FRC Season:

-Won FiT Waco District Event on an alliance with Team 624 CRyptonite and Team 2881 Lady CANs

-Ranked 34th out of 40 at the FiT DCMP Mercury Division

Both of these were huge accomplishments for our team last season and we hope to keep making progress going into the 2024 FRC Crescendo Season!

Website: https://bionicpanthers.org/

Instagram: Liberty Hill Robotics (@lhhsrobotics) • Instagram photos and videos

Youtube: https://youtube.com/@BionicPanthers

Github: Bionic Panthers · GitHub

CAD: (Coming Soon)

We will also be releasing our Team’s training materials which we’ve created in-house! Stay tuned!

Written By: @Madelena @moore_ryan @keyanmreza

openalliance

9 Likes

Bionic Panthers Training Library Release

Happy New Year! During this last December, after the conclusion of our BEST Robotics Season, leading up to the 2024 season, our team has been developing a formal series of training materials for our new rookies. This was the first time we have done something like this as a team, we think it had a positive outcome and hope our team can keep updating and utilizing it in the future! Take a look → (Google Drive Link).

The materials are divided into folders based on different FRC areas:

Intro to FRC: We designed this section to introduce the FRC competition and values (since most of our team participates in the BEST Robotics competition in the first half of the year), along with going more in-depth into the structure of our team for FRC. FRC awards, matches, event jobs, and more, are all covered in this section.

Beginner Mechanical: This section is intended to cover the physical tools and instruments we have at our lab, and is primarily a hands-on section with our lead mentor, Mr. Paschal.

Advanced Mechanical: Within this section, we cover more advanced tools like laser cutting, CNC milling and Lathes. We also incorporate projects that members can complete to get hands-on experience and showcase they can utilize these tools. During the prototyping/iteration processes, we use these advanced mechanical tools significantly, leading to the importance of this section.

Electrical: Electrical in relation to FRC is covered within this section. The basics of Voltage, Current, and Resistance are discussed, along with FRC-specific Electrical COTS parts that are available and that our team utilizes.

Beginner Design: A bulk of information regarding FRC mechanical design and our team’s processes are discussed in this section. We include a whole topic over our filename standardization, Mechanical COTS parts, analyses of our previous robots and numerous notable robots, and much more. We encouraged everyone on the team to attend presentations in this section.

Advanced CAD/Design: This past off-season we’ve done a lot of work towards streamlining our CADing process, along with setting many standards and procedures for our design process. This section delves into those improvements, and has a project towards the end applying these ideas, where team-members must design a gearbox based on a series of constraints.

Programming: Our programming lead helped develop this section over all things programming: our team’s coding standards and norms, the software and programmatic tools that we use, including coverage on Java, WPILib, Github, and FRC-specific tools such as Shuffleboard, Driver Station, and other utilities. Furthermore, we included a project where programming team members have to fix broken tank drive code. The project encourages new members to have all the necessary software and utility resources to understand the FRC specific WPI Java library that we utilize.

Scouting: Our Scouting system is in the process of a major overhaul this season from last season. Previously, we utilized Team 2052 KnightKrawler Robotics’ FRC Krawler system for our scouting needs, but we are currently working on our own Scouting application, thanks to Team 5411 RoboTalons’ assistance! We will update this section once we have finished development on the application and our training behind it!

We hope that our Training Library can be a useful resource for other teams in developing their own educational resources!

These presentations were presented live, so in some instances, bits of information may not be on the slides themselves, so please respond with any questions! We’re happy to answer any thoughts!

3 Likes

Pre-Season CAD Release

I am excited to share an overview of some CAD projects my team and I have taken up!

Here is an overview of what’s to come:

  1. MAXSwerve Module Shield
  2. Inventor Part and Drawing Templates
  3. 40 BAG Motor Drivetrain
  4. West Coast Drive
  5. WCP Elevator

MAXSwerve Module Shield (OnShape Import)(Inventor Source File)

Since the NEO Vortex and NEO 550 are outrunning motors we were concerned over potential damage to the motors during competition. This part was designed out of .125” 5025 aluminum to be cut by a vendor like fabworks (quote) with PEM 10-32 hardware installed for easy module mounting. This design has not been manufactured or tested. But we want to share our journey in this design!

Inventor Part Templates (Inventor Files)

We made these to make our CAD more streamlined and standardized. We have been creating templates of commonly utilized parts like fasteners, tubing, and manufacturing drawings. These are shown below. Here is a document explaining how to use them with Inventor

Bolt Templates

Features

  1. Simplified model:

  2. Head size is simplified for clearance purposes

  3. Visual threads only

  4. Made for each size we stock:

  5. Button Head: 2,4,6,8,10

  6. Socket Head: ¼

  7. Configurable length in the parameter tab “bolt_length”

Hex Shaft Template

Features:

  1. Configurable length and size in the parameters tab (“ShaftLength” and “ShaftSize” accordingly)
  2. Optional shaft retention holes.

  1. Optional rounded shaft ends for our ⅜” round bearings (WCP).

|318x519.8988876749997

1x2 Tubing Template

Features:

  1. Configurable dimensions.

  2. Wall_Thickness

  3. Tube_Length

  4. HoleSize

  5. Hole_Offset

  6. Optional hole patterns on 1” or 2” faces.

Manufacturing Drawing Template

This drawing template was made to streamline and standardize our manufacturing process. Utilizing a custom title block we have made sure all necessary information is given to the manufacturing student.

40 BAG Motor Drivetrain (Inventor Files)

This was made as a joke about how it was technically a legal design, before FRC released the motor rule change. :frowning:

West Coast Drive (Inventor Files)

This was made as a demonstration of our part numbering system and shown during our December training sessions.

WCP Elevator (Inventor Files)


While unfinished, this design was heavily inspired by the Grey T Cascade Elevator; it used different bearing blocks and is premade to work with our part numbering system.

That is all we’ve got for now! Feel free to ask questions or look into our CAD files.

4 Likes

Programming Update - 24’ Migration

With the new year, comes new software libraries!
With this, our programming team started our migration of our off-season swerve code (based off the REV swerve template) to 24’.

The REV 24’ changelog was very helpful for our team to understand the REV changes, especially with the release of the SPARK Flex.

Here’s what we have done in the pre-season & just after kickoff:
Toggle switch for field/robot centric.
Screenshot 2024-01-11 113146
Screenshot 2024-01-11 113133
We still have some issues with this, mostly logic issues that are being troubleshooted.

Some auton commands & useful extras:
image
We created these commands to test our autonomous capabilities with swerve, and to assist our drivers, they include:

  • Driving in an S curve (not fully working yet)
  • Turning 90° in a snap motion
  • Setting modules to an X pattern to prevent sliding (included with REV swerve template)
  • Reset heading command to change orientation of where “front” is while in field centric control scheme

Issues

Some issues we encountered while migrating our code were with CTRE and the Pigeon2.
We are having errors with the “Rotation2d” class, which, to put it simply, takes the angle from a point, and returns a continuous value, rather than resetting from 360 → 0


We have yet to take a deeper look into this error, but it was worth mentioning.

Another issue we are having is with our build.gradle file, probably due to migration or cloning our 23’ code to a 24’ repository

What’s Next?

Our programming teams’ plans for the next week or so are the following:

  • To discuss pathweaver vs. pathplanner & decide which to use this season.

  • Create subsystems in our code, preferably before a robot prototype is made (Shooter, Intake, Indexer, Climber, etc.)

  • Create some extra commands that could help during the season, such as a shoot command, or maybe LED functionality.

  • Test an auton path created from either pathweaver or pathplanner.

  • Create & test vision recognition for April Tags

That’s our update for this week, below you’ll find some links that were used/created/helpful to us this week:
Quick Installation guide
CD post detailing steps to April Tag recognition (with limelight 3)
Our Github

3 Likes

Mechanical Update 1/10

Shop Stock

We have been very fortunate (thanks to our business team) to get a $5000 grant from our ISD’s Education Foundation this last December in addition to some other sponsorships. This has allowed us to order a lot more parts than previous years.

We finally got our cnc to cut aluminum parts!

We have had a Carbide Create Shapeoko 3 that we used to use with the included palm router for years, now we installed the VFD Spindle upgrade and it works well at cutting aluminum parts! This will open up our designs significantly because we won’t need our machining sponsor to cut as many of our metal parts.

New Tooling!

Over the offseason our Engineering program (who we share tools/space with) bought a new Grizzly mill and lathe. This will definitely increase our ability to make custom parts.

Our laser has broken :frowning:

Our laser cutter has been working well since we got it in 2019 but on Monday our laser tube went bad. This machine was very useful to our rapid prototyping and development. This will delay us slightly, but we can make up ground with our cnc machine and hand cutting parts. We are working on getting a replacement tube, but it likely won’t come in time for prototypes.

We got our NEO Vortex/SPARK Flex’s!

Around when they were announced we ordered 9 Vortexes, Flexes, and MAXSwerve shafts so that we could have two swerve chassis running during the season. They have not been driven, but installation has been very simple.

We have noticed an issue that if the docking screws are too tight the Vortex will spin with a notably larger resistance by hand. Rev’s docs reference a 11.5 ±0.9 in-lb torque, but we have not tested this torque spec yet.

Bonus Video of the undisputed strength of a ⅛” Polycarbonate belly pan:

|207x365.8366800535475

That’s all we have for now!

5 Likes

Week 1 Recap | Strategy and Design

In summary this is how our team has been developing our strategy and design for this season. Right now we have been prototyping, doing high-level CAD and marking requirements. Most systems we are using to develop this are new so this post is quite wordy going to these systems and why we chose them.

Kick-Off!!

Everything is NEW!

It was our first time doing a virtual kickoff at our high school to watch the stream. In the past, we traveled to another school along with other teams in the area and all watched the kick-off together and picked up our kit.

We decided to only do a team kick-off to better use our time instead of traveling and it also worked out that they weren’t going to host an in-person kick-off near us anyways this year.

I have been helping develop some more systems so our team can be more organized and this gave me a chance to have more time with the team day of kick-off. After doing more research from other teams and developing our team’s system, our kick off day we tried a lot of new tasks towards developing a strategy and design, that I would say paid off

Schedule/overview

Due to an unfortunate power outage the morning of kick off at our school, we almost didn’t meet as a team day of kickoff but luckily it got back on just in time. The team met from 10:00 - 3:00.

10:00 am - Doors Open
10:15 am- Set Team Goals
    Will, Wants, Reach

11:00 am - Kickoff stream starts

12:00 pm - Eat lunch
    Read Rules
    FRC Game Manual Worksheet
    Pick up kit (Paschal)

1:00 pm - High-Level Requirements
    Identify Task
    Prioritize Task
    Categorize Task
    Compare Category with Goals

Team Goals (New!!)

Before we knew the game, we wanted to develop as a team goal for the season. Separating into three groups, each group developed wills, and wants, and reached for goals. At the end, we all met and each group got to share, and give the ability for the team to add and collaborate for some goals.

Competitive
EX: Where do we want to place in events?
Non-Competitive/Logistical
EX: How many new sponsors? How many community events?
Rookie team
EX: How far in a design they want to build?
(New! This year due to an increase in members on this team, We separated our engineering side of the team based on skill and experience, where this team will build a less complex robot that won’t compete but we hope this will help them to get hands-on experience and build the skills necessary to make more complex mechanisms)

FRC Game Manual Worksheet(new!)

Of course, after watching the stream, our team eats lunch and reads the rules, but this year we added a worksheet to do as they read. We got the idea from 1678’s rule quiz but we wanted it to be more a team activity rather than a quiz. Our leadership team developed the questions.

The questions:

  1. What are the points for auto-scoring?
  2. What are the points for teleop scoring?
  3. How can each Ranking Point be earned?
  4. Are there any ways to lower the Ranking Points requirements?
  5. How large is the starting configuration?
  6. How far can the Robot extend? Out of how many sides at once?
  7. In what areas of the field can it extend?
  8. How many game pieces, of what kind, can it hold at once?
  9. Where can each piece score?
  10. Where can you get each game piece?
  11. Are there safe zones?
  12. Are there game-specific penalties?
  13. What is the End Game?
  14. Notes:

High-Level Requirements

This where we start the season when talking about robot design, We as a team list every possibly task (Functional Requirement) that there was, identified what type of team would do it and if we want to do that task as a will/want/reach

At the end we also Added non-functional requirements (Ex: robust) this is what we ended with.

SubSystems (Meetings 2-4)

Meeting 2

Requirements

Leave where we left off we disused after people got a chance to go home, research, and design if we want to add or change are requirements we end on kick off. As you can see we made some changes:

Sharing

Our next topic was discussing what type of subsystems and there requirements would they haves so before we did that we gave everyone a chance to present and share ideas. The ideas had these ranged from white board drawings to Krayon CAD to Inventor CADs.
Here are two students Onshape documents: Ryan and Keyan

|393.4642857142858x439.53430330632654
|349.0477489768076x386.7306376012124
|444.26315789473693x453.55534869901874
|328.70848708487085x306.15683023335055

Subsystems

Next, we moved into listing all the different type of subsystems we wanted our robot to have.

Then expanding each subsystem plus the the general requirements each subsystem has. this is a base to start limiting designs and further design more like what we as a team wanted to accomplish

Testing and Prototyping

Between meetings 2 and 3 much of our team was prototyping and testing, demonstrating Vertical shooter at different compressions and different speeds as well as a horizontal roller at different speeds. Below I have attached a few of these videos

Meeting 3

Giving more people the opportunity to further share design, prototyping and test videos from either our team or other teams we started to limit designs based on a design matrix as you can see below, everyone voted from 1-5 based of they criteria and what we saw from protyping and testing

Conclusion of meeting

  • Under the bumper roller intake
    • that can fold inside the robot
  • Horizontal roller shutter on a pivot
  • Fixed elevator
  • Left to decide for meeting 4
    • Do we want a push bar for amp/trap scoring?
    • Is the indexer going to pivot?
    • Are the intake and shooter going to be on the same or opposite sides?

Ending week 1

Our next meeting we will finish the design matrix form meeting 3 and start fleshing out requirements and placement of said subsystems. We have continued the test, in meeting 3 we decided to go with horizontal rollers so we were testing ways that we could shoot into the amp, videos to come!!

Very Excited for Week 2 and more to come!

By: Madelena Flores (Team Captain 8088)

5 Likes

Programming Update - Pathplanner!

Last year (Charged Up), we attempted to use pathweaver to make a path for our KOP chassis, and failed. The most we could do was place a cone on a high node, and gain a mobility bonus.

This year, thanks to our design choice to use REV swerve modules, we took another look into path following programs for auton, and PathPlanner decended from the heavens :pray:
Here is one example of what we have tested in PathPlanner’s UI:

One of the biggest reasons that our TEAM decided to move to pathplanner over pathweaver, was because of their code to follow paths.
With pathweaver, it was much more complicated, and we had never actually managed to get code to follow a path.
We managed to create a error-free path following code, albeit not tested yet.

To sum up the code fixes/changes, we created some global variables for math equations, and created a path to an already existing command.
This changes allowed us to make our code error-free.

Deep Explaination of Code

To start, this image shows the code from pathplanner’s website, mentioned earlier, but filled in with our own commands.

The first command, getPose(), already existed and was easy to implement. It returns the pose (combination of x, y, and rotation)
image

The next command, resetOdometry, effectively resets the pose to zero.
image

The third command, getChassisSpeed, returns ChassisSpeed, from global
xSpeed, ySpeed, and rotation values.

The last, and most complicated command that took super long to figure out, setChassisSpeed:
image


image
image
To summarize it, it creates a path for the drive subsystem to run toswervemodulestate via constants.java

We are waiting on REV to send out a fix for this issue (CTRE & REV conflicts), before we test our swerve chassis, as we do not want to replace our Vortex motors with Neos too hastily.

Previous Issues

To start, we fixed our build.gradle error from last week’s programming update.

We found this resource explaining how to fix the error.

We also fixed our Rotation2d class error, which was caused because when we called .getYaw() from our gyro, it returned a StatusSignal< double >, rather than just a double. It has been replaced with .getAngle(), which returns the heading of the robot, same as yaw.

What’s Next?

Due to us not being able to meet on our scheduled days this week, (due to weather), we have not made much progress other than that listed above.
We plan on doing the following between now and next weekly update:

  • Tune drive PID for Vortex motors, rather than NEOs, (we are having oscillation issues)
  • Create subsystems
  • Test PathPlanner paths on our swerve chassis
  • Test parallel & sequential commands with PathPlanner
  • Get our CANdle up and running, and create diagnostic lighting
  • Continue to fix our Drive commmands that are not working (see below)
Drive Commands

Ending Remarks/Statement(s)

We used The Grasshopper’s Github for some cross referencing of path following commands, see below for a link to it. To be more specific, we referenced their path following commands, and we realized that we already had pieces of what we needed to do in our code, we just needed to put it together.

Our TEAM came up with a remix of The 12 Days of Christmas, and I’d thought I’d share it here:

Lyrics

:musical_note:On the fifth day of Christmas
My lead programmer gave to me
Five golden notes,
Four speaker shots,
Three amp notes,
Two climbing bots’
And a red card from a referee🎵

That’s our update for this week, below you’ll find some links that were used/created/helpful to us this week:
Our Github
PathPlanner getting started
The Grasshopper’s (95) Github, used for some cross-referencing
ChassisSpeed documentation

Written by @xactlysharp

6 Likes

A fix for this has now been published with the new SPARK Flex firmware 24.0.4 we just released

5 Likes

Thanks for informing us!

1 Like

Hey just popping in to let you know that the ChassisSpeeds supplier here will give better results if returning the current measured ChassisSpeeds of the robot, not the last speeds that were output from the code. You can get this using your kinematics, it has a toChassisSpeeds method that will convert your current module states to ChassisSpeeds.

1 Like

Thanks, ill implement that when I get a chance

Week 2 Recap | Finishing Up Major Desing Descions| Neo Vortex’s| Frog or an Alligator?

This week was a lot of decision-making and debugging

Finishing Up Major Design Decisions- Meeting

This meeting was done pretty early on in the week so you can see how the progress through the week after we finished up these decisions

Index/ Storage for note

  • index that articulates with the shooter
  • fully autonomous

Bar for Amp

  • outcome - yes, after testing with our horizontal roller
  • We tried doing it with a push bar, shooting out at an angle, and spinning the front and back in rollers in different directions but the only one we could constantly be using a bar for the amp(Video)

Sensors and programming

  • What does programming need to make the team’s requirements work with the mechanism chosen?
  • Outcome:

Placements

  • we first laid out requirements for the placement of major mechanisms
  • Outcome:

Naming system

  • This year we wanted a naming system that was the same across all teams
  • Our Engineering Team Managers and I sat down and determined the names
  • Outcome:
    |246x326.89470164654693

Rest of the week:

  • Programming
    • Test, test swerve chassis with Neo Vortex and SparkFlex (Mechanical Update 1/10)
    • Start Testing auton
    • Create a subsystem for each mechanism
  • Mechanical
    • Amp Testing
    • Robot in a box
  • CAD
    • Master Sketch
    • Volumes
      • Prioritize getting chassis size to adjust our test chassis to comp. chassis specs

Programming - Problems?

We ran into two major problems

New Vortex/Flexs

We ran into two major problems

New Vortex/Flexs

  • We got all the firmware updates without any trouble and changed the code to work with Flex’s in the code
  • Trouble came when we started driving it,
    • All of the motors were oscillating and one motor was not spinning at all (Video)
    • we never found a solution and replaced it with another vortex which “moved”
      • with the information we have now about the solution to oscillation we need to separately test that motor and find the root of the problem
    • All of the Motors are oscillating when we drive (Video)
      • We troubleshoot the wiring and tuning PID, but nothing fixed it
  • We eventually found the problem was the firmware, it didn’t like REV and CTRE on the same CAN chain, we are using a pigeon 2.0
  • REV pushed a firmware update to solve the problem, after I updated the firmware as you can see it fixed the oscillation problem

Path Planner

  • For the first time, this year we decided to write auton code through Pathplanner
  • We had some trouble integrating the path planner code
    • details on the solution linked below
  • We have not tested path planner yet but we got one more step closer

Solutions on the Vortex and path planner more in-depth - Programming Update

Mechanical

Most of our mechanical was stalled this week due to CAD starting and troubleshooting the swerve chassis with programming as discussed above

We finally finished our Robot-In-A-Box

  • We have seen other teams do this and along with encouragement from one of our mentors (he supplied us with old 911 cases to build it in)
  • It is all of the control system and electronics of a robot in a box
  • This will allow programmers to take it home
  • allows us to test mechanisms and motors not attached to our robot

|343.44871794871796x257

CAD

Our CAD team was hard at work this week

Laying out motors per sub-system/mechansism

Master Side Sketch

Volume CAD(everything except the elevator)

|1219x717.9905733900873

^^Question of the week, Does the volume CAD look like a Frog or an Alligator?^^

This has been a converse discussion on our team

  • Frog
  • Alligator
0 voters

Science Night

The team ended week 2 by being able to participate in a local science night and we had lots of fun!!
https://www.instagram.com/p/C2Q2_kOsXTI/?img_index=1

More to come :slightly_smiling_face:

By Madelena Flores (8088 Team Captain)

9 Likes

Programming Update - It’s Alive!!

Our [test] chassis finally moves!
After finishing up the wiring for the chassis, programming got the chance to test our code!
Here’s a video of it in action:

Our TEAM recently finished building our test chassis, as you can probably infer, but I just want to highlight how nice it is (and how much time it saves!) to have a chassis just for programming, as well as our “Robot-In-A-Box:”

PathPlanner & Code Changes

To share even more good news, our PathPlanner code works!

An explanation of our PathPlanner code can be found below:

Explanation

Firstly, here is an explanation of our path following code, which was explained in last week’s programming update:

Explanation v2

We did make some changes to this code, as well as our AutonChooser, which I’ll explain now.
We re-did our getChassisSpeed function to actually provide accurate, and real-time values:


This hasn’t been rigorously tested yet, but it has proven to work in a few short tests.

We also fixed our AutonChooser code, were we can run autos from Shuffleboard:
image
I’ll omit the rest of the code, as it is taken directly from PathPlanner’s getting started guide.

To summarize, we just had to call the right class/function and match names to the names of the autons in the PathPlanner UI.

Thanks to our test chassis and working PathPlanner code, we can finally record testing videos of Autonomous programs!
Here are a few:

Video of our robot running a circle path auto (for testing drift and such):

Video of our robot running a 4/5 note auto (drivetrain only):

Video of PathPlanner’s built in telemetry while running an auto:

While the programming TEAM was waiting for our mechanical TEAM, we had the chance to do some code organization and some monotonous tasks while we waited.

We decided to classify our robot commands into folders as shown below:
image

Our motivation to switch to folders was mainly to avoid this:


Our 23’ code

This was a little over half of our commands…

Along with this organization, we created “templates” for our subsystems.
We included imports, motor initialization & configuration, as well as some basic commands that we may need, shown below:
image

As you may see in the above image (MotorSpeeds.barRotatorSpeed), our TEAM decided to use our Constants.java file as much as possible this year. We have put the following into our constants file:

  • Device CAN IDs
  • Motor Speeds (not yet tuned)
  • Drive PID variables
  • Drivetrain Settings (chassis length, etc.)

We hope that using the Constants file will allow us to have one place for everything, no more mindless searching for one random number.

We also have our constants file sub-categorized into CAN IDs, Motor Speeds, Drivetrain settings, etc.

Issues

We didn’t encounter any major issues this past week, but here are some of the small ones that we came across:

Edit: We had some issues with our drive chassis, it seemed to be continuously resetting it’s heading, we are troubleshooting it currently.

  • Github desktop doesn’t copy empty folders (from the commands folders I mentioned earlier). Fixed by adding a simple text file to all of the folders.
  • Had a bit of trouble with CTRE’s Falcon 500 initalization, but found the right imports after a bit of trial and error.
  • Changed our AutonSelector from this:
    Screenshot 2024-01-25 091045
    To this:
    image
    And with that, running autons from Shuffleboard now work
  • Lastly, we had a bit of trouble connecting to our Limelight3, but it was resolved quickly. (To be more specific, we wired it wrong, and quickly fixed it.)

What’s next?

Here are our plans for next week:

  • Add command files for basic stuff (intake in/out/stop, etc.)
  • Continue to work on Limelight April Tag recognition
  • Test sequential/parallel commands with PathPlanner
  • Test PathPlanner with the robot not propped off the ground
  • Consider working on LED funtionality (still waiting on CANdle)
  • Troubleshoot chassis issues that arise

Ending Remarks/Statement(s)

Big thanks to @Greg_Needel for letting us know of the REV/CTRE conflict fix.
Another big thanks to @mjansen4857 for letting us know of an issue in our PathPlanner code.

Apologizes if the testing videos seem rushed / low quality / if my face was in the way too much…
Was in a bit of a rush to get them recorded

To clarify one thing, I commonly capitalize “TEAM,” that is because our lead mentor does the same, as they see “TEAM” as an acronym (Together everyone achieves more.)

Useful links from this week:
Our github
3d Visualization of April Tags with Limelight
Testing videos playlist
Moving while shooting CD thread

5 Likes

Week 3 Recap| CAD Progress| Autonomous Paths

CAD Volume Review

We started the week out with a CAD review on Sunday reviewing the Volume CAD completed last week

Elevator/climber

  • our climbing design in is 2 stage elevator that can approximately reach up to 44in
  • We referenced a sketch (by @moore_ryan ) that determined the chain height from ground, on different points being tensioned (simulating a climber polling on
  • Our current climber we realized we could build it to:
    • Only hang in the middle but then couldn’t hang on edges
      • Would short enough that the front of our robot would get off the ground
      • In turn making it not tall enough to get edges
    • Only hang on the edges but not the middle
      • Would be logn enough to reach the edges of the chain
      • inturn too long to hang in the middle, because our front wheels wouldn’t be able to get pulled off the ground
      • This lead us to:
        • We thought the only way to be able to score in the trap would be to hang in the middle so this would eliminate that
        • having an only edge of the chain would eliminate the trap with that belif
        • But then we saw some teams scoring in the trap from the ground
  • In this conversation we also really like the idea of having a climber that we could hang vertically on the chain at the edge

(Idea from AngleBotics)

  • Elevator Outcome
    • We only Hang on one edge/side of the chain
      • to increase ability to do Harmony
    • First priority - This 2 stage Elevator
      • Our team is familiar with this system
      • We know we can build it fast
      • Less risky climb at first event
    • Second priority - Other Climber
      • Potentially a vertical Climb?
        • Wench?
      • When mechanical team has time(after robot and first priority climber)
      • It must be able to be mounted on robot in same place the first priority elevator is

Other outcomes/decisions

  • Only score Trap from shooting on the ground
    • based on elevator decision
  • 12T pinion on Comp. Swerve module
    • Mechanical
      • Change test chassis module gearing
      • Start assembling comp. Chassis module
    • Programming - update code to reflect change
  • High fidelity CAD Due Sunday
    • Will have High fidelity CAD review on Sunday

Hook Testing

The idea with this hook design is for it to autocorrect on any orientation of a chain and slide on it to where it can’t then slip down the chain

Autonomous Paths

We finally got path planner running Below is a Test path (@Xactlysharp)

We planned our auton paths, planning for 8 total, 4 different ones on each side

  • Amp side of Speaker, 3 note auton
  • Middle of Speaker, 3 note auton
  • Source side of speaker, 4 note auton
  • Best cast senorio, 4 note auton

These are Rough Paths, created in path planner to start visualizing these autons


CAD Progress

Cad teams have been working super hard to get a high-fidelity CAD done, Below are some pictures of the progress over the week

Other accomplishments this week

  • Mechanical

    • Change test chassis with 12T - as determined by the Review earlier this week
    • Assembled Swerve modules for comp. Chassis
  • Programming

    • Started configuring Limelight and got it to recognize the April tag
  • Ended up deciding against doing a second-priority elevator from the meeting earlier this week

Stay Tuned Week 4 brings:
  • Full robot CAD
  • Manufacturing and assembling of comp. robot
  • More fleshed out auton paths
  • April tag test and implementation

By Madelena Flores (8088 Team Captain)

6 Likes

Week 4 Recap| Full Robot CAD| Manufacturing

High-fidelity CAD review

Started this week with a CAD review, last week you saw our CAD team start to work out volumes and how everything integrates, here you can see more clearly our vision.


Main takeaways

  • Side plates for the shooter, intake
    • Potentially have aluminum plates instead of polycarbonate
  • Aluminum gears might run down on the pivot
    • Steel gears ordered from WCP to replace it
  • Pivot gearbox, too pocked
    • Should increase rib/fillet size
  • We have a lot of electronics on the side panels
    • Will need to find ways to secure the connection
    • Put vibration damping on it
  • Need bridging between the hooks on the elevator
  • The shooter was intended to have falcons on it
    • But we only have 2, so no backups
    • Switched to Neos in hopes we can get vortex’s to put on the shooter
  • Storage for the Note, Planned to have a through beam
    • Have to test, we can see potential issues
  • Where do we mount Blinky
    • Plans to find a spot on the elevator
  • Mechanical Priority
    • DriveTrain
    • Shooter
    • Pivote
    • Intake
    • Elevator

Manufacturing and Testing

This year we have made some changes to our manufacturing/assembly process:

  • Standard Part Number System
  • Making drawings for each Assembly/Part
  • Implementing that with our Monday.com task

Our manufacturing process has sped up a lot this year

Each task has a:

  • Part #/name
    • Each assembly has all the parts under it
  • Manufacturer
  • Status
  • Drawing file
  • Tool assigned
  • Quantity needed
  • Inspector (usually the Mechanical Manager)
  • Checked Date

Example with our Shooter/Storage

Overall progress of our manufacturing

Drive Train Progress

Pivot Progress and Testing

Intake Progress and Testing

Bonus feature of our drive train:

Ended our week with our first-ever Camp

A take-a-part camp with robotics activities and demonstrations

Was super successful with our first time hosting any event, can’t wait to do more in the future!!

Next week, will send out more progress on the robot and Shooter progress and testing

By Madelena Flores (8088 Team Captain)

5 Likes

Programming Update - Stateflows, PID Loops, and Trigonometry!

We decided not to post a programming update last week, mostly because we had almost nothing to post. It’s the exact opposite now!

Starting to tackle the big list of what we’ve done over the last 2 weeks, let’s get into Stateflows! (Our TEAM has experience with stateflows from BEST Robotics)

Our programming TEAM had a meeting with a few of our mentors about creating a detailed design plan, and not just something like:

But rather, a detailed list that explains every step in the process.
We ended up with this, which explains the process of our “prep to shoot” command:


High Res version

To sum up the stateflow, we run our pivot, shooter, and aim (left-right) PID loops given our limelight data, update them every 20ms, and stop once a note is shot or process is aborted.

We decided to use Lucidcharts to design our stateflows, as they are similar to Matlab’s Stateflows, which is where we have our stateflow experience from.

Why Stateflows?

We decided to use stateflows because they outline exactly what we need to do, rather than just a title of a task on a work managment site like monday.com (still useful but not super in-depth).

Because they go into so much detail, we can reference them while we write our code, and they heavily streamline the process of writing said code.

PID Loops

Taking a look at our actual code that we’ve created these past 2 weeks, we have our shooter speed PID and our pivot angle PID.

Our shooter PID is as follows:
Define P, I & D values in constants.java:

image

Set up the PIDController in the Shooter subsystem:

Use the PID in a command, also in the Shooter subsystem:

image

This compares the actual speed of the motor with the commanded speed, different from our pivot PID, which I’ll get into now:

Our pivot PID loop is very similar to our shooter PID, but compares our absolute encoder (angle in degrees) to a degree setpoint.

image

Comparing to an absolute encoder allows us to use a setpoint for angle, rather than speed.

We hope to test these PID loops as soon as we can.

Auton Paths

@Madelena already refered to these in this post, but I’ll take a bit of a deeper look.

Our TEAM decided to have ~8 total autons (4 per side).

Each path starts at either the top, middle, or bottom of the subwoofer, so we can still run a high scoring auton no matter where our alliance members are.

We also created a “[Color]NoteClear” path, which we would run if our autonomous paths end up to be more reliable / score higher than our teamates’ autons.

We created the paths with shooting in mind, and added rotation targets so our robot will be facing the speaker when we need to fire a note.

Here’s a gif to show the path for one of our autons (keep in mind this hasn’t been tested yet, and is just theoretical):
02071-ezgif.com-video-to-gif-converter

Trigonometry

While creating our shooter and pivot PIDs, we found that we needed a command that could return distance from known constants (and limelight data)

Here it is:


It takes the equation from this page, and puts in our own constants .

It was quick and easy to make, but it’s worth mentioning.

Issues

We had some issues these past 2 weeks that are worth mentioning:

  • Accidentally set all of our “isFinished” commands to true, causing all commands to not work.
    image

  • Had some issues declaring subsystems in RobotContainer, just minor misspellings and such (not shown below)
    image

  • Originally created a list of motor speeds in an array with an index for shooting speed / pivot angle, but decided with the equations because the equations are more accurate

  • We had a backwards CAN cable which caused some weird stuff with our robot

  • We tried to make an Interpolation / LUT (Lookup Table), but decided to go with linear equations instead, due to the simplicity of them.

  • Issues with WPILIB (I didnt update it…)

What’s Next?

  • Create a PID to aim the swerve chassis to an Apriltag, while still being able to drive (translate, but not rotate)
  • Tune the many, many PID loops, and equations
  • Finish sequential command that has fully automated intake → ready to shoot

Ending Remarks

Would you rather have videos of testing be in a GIF or a YT video? GIFs have less quality and no audio, but auto-play in posts, and don’t require an external site, like Youtube.

  • GIF
  • Youtube Video
0 voters

Useful links from this week:
Our Github
Vison Processing
Interpolation Topic
PID Controller Class
Rembrandts (4481) Github (Interpolation Reference)
Rembrandts (4481) Build Thread

5 Likes

Week 5 Recap| Manufacturing and More

This week was full of manufacturing, wiring, and assembly work on the robot, with programming testing along the way.

We had a high-detail CAD but we still wanted to start with a plywood version first so at the beginning of the week our plates/panels were made out of plywood, and over the week after testing you will see the plates/panels we replaced with aluminum. And we are glad to have done this because after the plywood version, we did need to make minor adjustments, like tensioning on belts, and access holes.

Drive Train, Under Bumper Intake, & Pivot Gearbox - Plywood Version

Plywood belly pan, under bumper intake, and our pivot gearbox/mounting

Shooter - Plywood Version

As you can see we put in on our shooter on the pivot to see how it fits.

|318.99999999999994x424.8253300166862|344x457.9506221799933

|328.99999999999994x439.4549759935326|376.71022983325827x505.4130018429339

Replacing with aluminum

Shooter TESTING

These tests were with NEOs on the shooter wheels as we were waiting for our second Vortex/Flex order to come.

Shooter - Polycarb Version

|589.5x540.5406898456652

Pivot TESTING

Everything fits together

Checking before finalizing electronics on the Drive Train

|436x581.1383043922369

Bar TESTING

Adding side panels

Which will function as:

  • Sponsor panels
  • Electronic mounts
  • Shield for our robot


The sides of our robot are pretty packed with wires, we learned our lesson this week when we needed to access the spark maxes, so it’s safe to say we are working on a better solution to being able to get to those spark maxes.

Elevator progress


Bumper design

The CAD sub-team has been working on finalizing the bumper mounding to hand off to the mechanical sub-team to be built. This year we have one connected square bumper. The bumper mounting was done in 1678 style.

Spotlight - Our rookies sub-team

Our engineering branch (Mechanical, CAD, and Programming sub-teams) is split into a competitive and a rookie (non-official) team. Our rookies are taking charge of building the kit bot.

I wanted to highlight their progress this past week.

|1536x2048.7226525331935

We also took part in our school Freshman Course Fair tonight, which our rookie members took charge of helping with while our Competitive was making progress in manufacturing

|430.99999999999994x322.3984117562768

More to come! The team’s been super excited to get the robot up and running

|435.99999999999994x581.1073056901365

By Madelena Flores (8088 Team Captain)

6 Likes

Programming Update - Robot Testing?!?! Finally!

By @Xactlysharp

CANdle & Controllable LEDs

To start, our [programming] TEAM has spent their free time this week working on the CANdle, and functionality to control external LEDs, and extras like animations.

Why? Well, because of driver signaling (and looks). If you look at this video from last year, at 0:42, you can see our CANdle (on top of our robot, near blinky) shine yellow, to signal to our Human Player that the drivers wanted a cone (purple for a cube).


see blue circle

This was very helpful last year, and we wanted to continue doing it this year. Read a more detailed plan in the What’s Next? section.

We are accomplishing this by following the example on the CANdle bring-up page by CTRE. Code-wise, we are using a series of Ifs and If else(s) to establish a color or animation when a command is called.

We had some issues with switch statements, and are having issues with addressable LED strips. A [slightly] more detailed explaination can be found in the Issues topic.


Some of our addressable LED strips on our robot

PIDs & Pivots

We focused a significant amount of our attention this week on our Pivot & Shooter subsystems, specifically the PIDs for them. We use PIDs for both of them so we can easily feed the command one number, and then the respective subsystem will go to that angle/speed.

We use WPIlib’s PID controller class to achieve this. We also have a linear slope command to generate angle of Pivot given distance.


Image of our Pivot Subsystem

Distance & Disaster?

This title is a little misleading, but “Distance & Disaster?” just sounds too good to pass up.

To calculate the distance mentioned previously, we applied some math, thanks to one of our mentors for writing this all out:

However, our command for this doesn’t seem to work yet (the “disaster”), we are currently troubleshooting it (that’s about all we know about it, so I won’t include that in the Issues topic).


Math isn’t updated in this screenshot

Issues

  • CANdle Switch statement issue: We had some issues with switch statements, so we resorted to just ifs and else ifs.
  • CANdle addressable LED strip issues: We can’t seem to control the LED strips, or get them to turn on. We think it may be an issue with the configuration of the CANdle, because we are powering the LEDs via 12v passthrough.
  • Somehow, our Pigeon 2.0 got unplugged, but it was re-plugged in and it fixed our chassis, which wasn’t driving (because the Pigeon was unplugged).

What’s Next?

We plan to do the following next week:

  • Robot Testing! Thats what the title is all about, our mechanical TEAM is [almost] done with the robot, so we programmers can finally test stuff! Here’s what we are going to test:
  • Aiming with our drivetrain (our shooter is not turreted)
  • GetDistance command testing
  • Tuning, tuning & more tuning (PID loops, linear equations)

Ending Remarks

All of this is everything that happened up to Thursday, 2/15/24. I wasn’t able to finish the update by then and was busy during the weekend, so it doesn’t include any work done during the weekend or on Monday.

Here are the links that were useful to us this week:

3 Likes

Week 6 Recap | Intake and Elevator

This post is a little late and short because we have been working non-stop! I appreciate your patience

Starting with an exciting note at the beginning of the week! We have NOTES!

We now have 13 notes! 6 from Freedom Rider, 6 from AndyMark, and our KoP note.

|540x721.1738281886161

Intaking

So we got the intake on, did some testing, and realized we were slipping on our belts, for the intake and we decided we needed more tension on the intake retraction belt, so after fixing that we have an intake!!

Here you can see our Auto intake testing works now

Beginning of common

  • intake pivot down
  • Feed intake
  • Feed transfer rollers (intermediary stage)
  • Feed Storage Rollers

Once the trough beam on our Stroge is broken

  • stops all rollers
  • intake pivot

more torque on the intake

Elevator

Programming

Started to make sure everything is running the correct way and limits correctly

Upcoming Week 7 recap

  • Auto Aim while driving
    • keeps shooter aimed at the speaker
    • continuously angles shooter based on distance
    • continuously revs shooter motor speed based on distance
  • Amp scoring
  • Hanging

By Madelena Flores (8088 Team Captain)

5 Likes

Programming Update - Final Touches!

By @Xactlysharp

Aim w/ Drivetrain

As you can probably infer from our robot pictures, we don’t have a turreted shooter. Because drivers aren’t perfect, we needed an Aim command.

How?
Through the setModuleStates commands & ChassisSpeed class:

Using this implementation allows us to still drive the robot in the x-y translation (see controller axis above) while still turning towards the AT.

At first, we tried to accomplish this with the normal drive() command, but that didn’t work. So we did this, (and it worked first try!)

Here’s a video of our robot aiming:

Shooter, it Shoots!

Our shooter finally shoots! Here’s a video:

Still tuning the pivot angle

How? With math & data!
I’ve already explained the commands behind this in previous posts, so I’ll just put the newest code here:



LEDs?

As I’ve mentioned in previous posts, we have a CANdle & external LED strips for driver signaling.

We can’t seem to get these to work, so we are troubleshooting both the electrical and programming side of things.

The commands work just fine, but only set the CANdle built-in LEDs, and not the external ones.

Here’s our CANdle config & [parts of] commands:
image
image

Issues

  • External LEDs not being controlled
  • Pigeon issues, either not calibrated, or something similar
  • Pivot slope needs slight changes

What’s Next?

We plan to do the following next week in anticipation of our week 1 competition:

  • Driver Practice!
  • Test Autonomous commands as the drivers are practicing
  • Continue to fix LEDs
  • Fix field centric not working

Ending Remarks

Bit of a shorter post this week, but it encompasses almost everything.

Here are the links that were useful to us this week:

5 Likes