NerdHerd 687 OpenAlliance Build Thread 2023

The Nerd Herd 687 | Build Thread 2023

Welcome to Team 687 The Nerd Herd’s build thread for the 2023 Charged Up season! This will be our 23rd season and first season as part of The Open Alliance. We are really excited for the 2023 season and plan on going to 3 regionals:

We would like to thank our sponsors:

  • Gene Haas Foundation
  • Norris Foundation
  • Parker
  • Boeing
  • Raytheon
  • Raising Cane’s
  • OurOwnStyle

Team Resources:

2 Likes

January 7th Meeting

Kickoff

We decided that we wanted to start the season strong by doing Robot in 3 Days. On the first day, we started out by watching the livestream and coming up with robot and gameplay strategy. Afterwards, we mainly focused on design the first iteration of our robot and building the game elements.

Schedule:

  • 8:30 am - 9 am: Leads setup rooms and livestream
  • 9 am - 10 am: Watch livestream
  • 10 am – 12 pm: Game manual breakdown, strategy, setting goals, robot sketches
    • 30 min game manual
    • 15 min goal setting in big group
    • 35 min small group brainstorm about strategy and robot
    • 30 min big group brainstorm
      • Each group says a 60 second elevator pitch of their idea and
      • Use Pugh analysis to decide
  • 12 pm - 1 pm: Lunch (Potluck)
  • 1 pm - 3:30 pm: CAD / Assembly (field elements)
  • 4pm - 7 pm: CAD / Assembly (field elements)
  • 7pm – 7:30: Dinner
  • 7:30 pm - 10:30 pm: Manufacturing / Assembly (field elements)

Admin

After kickoff, we met as a subteam to prepare for the potluck during lunch. We cleaned the tables, set up the sterno trays, and organized food as parents brought in more. After the potluck, we made food order forms for many of the upcoming meetings and started the business plan. We used Excel to organize every section we needed to rewrite, and from there, we delegated the work accordingly. The rest of Admin took inventory of the new apparel and distributed the final orders to the remaining members. Meanwhile, Media worked on gathering footage for the first video recap. Later, some of Admin worked on the business plan, while the other part discussed plans for outreach this season. Afterwards, we planned dinner and met with Mr. Harder to discuss the stand-up banner.


Assembly

We used the field drawings and Read Me documents for the official field elements on the FIRST website. We decided to make the middle/end cone ramps, cube shelf, and the half charge station and bought all of the materials listed on each of the Read Me documents. We split our Assembly subteam into 3 groups; the middle cone ramp, the cube shelf, and the charge station. Using the “example cut list” on the Read Me documents, we measured everything onto the sheets of plywood and pieces of lumber for each field element. Each group cut everything out with the circular saw, bandsaw, and the hacksaw.

Note: got all materials and started measuring and cutting (no assembly)


CAD

Claw Intake

We wanted to incorporate four contact points with four wheels attached to four gears. We created a crayola CAD of our design and prototype with VEX parts.

Design 1

Crayola CAD of Claw Intake

Prototype of Claw Intake

Design Matrix:

Strengths Weaknesses
4 contact points 1 motor
Secure / strong Heavy
Easy to program Wire routing
Requires less precision

We also created another design, a linear actuator claw.

Crayola CAD of Linear Actuator Claw

Prototype of Linear Actuator Claw

Design Matrix:

Strengths Weaknesses
No Motor Needs to be precise
Lightweight
Easier to program
Carries both position and control

Lift Mechanism

We made a Crayola sketch of the linear and linear, elevator and telescope. We wanted to see if it was possible to reach both height and length of the highest node. It was possible, but it would be very close.

We decided to make the elevator on the side. We took inspiration from this design, and I wanted to make it sideways for more point of contact in the telescope as shown below.

Crayola CAD of Lift

Arm

Created crayolas of possible first iteration arm designs

Analyzed pros and cons of each design

Fixed point for arm

  • Telescope arm
  • How many stages in telescope?
  • Get game piece from shelf
  • Score in mid pole
  • Drop game piece into bottom row
Pros Cons
Simple first iteration Center of gravity
Unstable
No high scoring

Telescope arm at an angle

Crayola CAD of telescope arm at an angle on Day 1

  • Scores in both mid and top
  • Storing position actuated with pneumatics
  • No elevator
  • Intakes from shelf
Pros Cons
Simple and effective Very Heavy (arm is very long)
Center of gravity

Telescope arm on an elevator

Crayola CAD of Telescope arm on an elevator on Day 1

  • Multiple locations where it can intake
Pros Cons
able to quickly score in all rows Multiple telescope stages
Arm is heavy and suceptible to collisions
Complex

Pneumatic Arm

Crayola CAD of pneumatic arm on Day 1

Pros Cons
Extremely simple Unstable
Mid scoring only

Manufacturing

On the first day of RI3D, the manufacturing subteam CADed the measurement jig using the CAD drawings provided on the FRC website. We printed the cube measurement jig with the same weight (563.308g) as the one used at competition using density calculations.

3D Printed Cube Jig

Some of the manufacturing members assisted assembly with the swerve drive BOM. We discussed what parts of the swerve drive could be manufactured and which parts should be purchased.

We also assisted with the field element assembly after completing the cube measurement jig. This included measuring the wood to cut and band sawing them for the next day.


Programming

We made a new repository for 2023 and began writing the Drivetrain subsystem, as well as the auto using tank drive.

Vision, Arm, and Elevator

We specifically aimed to setup testbenches to run Limelights to detect AprilTags and reflective tape. With the help of our mentors, we based the design of our testbench off the following diagram:

Diagram of testbench setup

Then, we made several modifications to our testbenches such as supplying power to the RoboRIO after wires were disconnected, and updating RoboRIO firmware.

RoboRIO re-imaging process

For AprilTag recognition, we decided on the PhotonVision Limelight image as it included built-in support. However, after installing drivers onto the Limelight and imaging the Limelight using Balena Etcher, we discovered the hardware we were using was stuck in a boot loop. As we would not have access to new Limelights until tomorrow, we moved on to developing baseline code for our subsystems.

Because we are currently split among two drive bases: swerve and west coast, we decided to use a repository with an arm and elevator subsystem (two subsystems in common among all versions of code) as our main branch. The latest commit can be found here.

Swerve Drive

Today, we decided to work on programming our swerve drive system to test its feasibility in competition. We were able to get our drivebase to work with the help of our mentors, and may be considering using a similar design for our competition robot this season, if we are able to find parts to repair the drivebase when necessary.

Swerve Drivebase

Autonomous Pathing

  • First, our group came up with possible autonomous paths for our robot. The paths we came up with in order of development are:
  • Park on the charging station without it being level.
  • Park on the charging station and make it level.
  • Score a single preloaded cone and leave the community.
  • Score a single preloaded cone and park on the charging station to make it level.
  • Score a preloaded cone onto one of the side nodes, leave the community to pick up another cone from the playing field, and return to the community to score it in the hybrid node.
  • Score a preloaded cone onto one of the side nodes, leave the community to pick up another cone from the playing field, return to the community to score it in the hybrid node, and dock on the charging station to make it level.

We decided to focus on a path for docking and engaging on the charging station, as well as another path for scoring one preloaded cone onto one of the side nodes. We found the coordinates for these paths using the dimensions given on the drawings and game manual.

1 Like

January 8th Meeting

Admin

Admin met with our admin mentor to finalize the January and February snack donations and parent pick-up sign-up genius. Some members worked on a follow-up for spirit wear and finished a form for propellor hats and pajama pants. We finished the majority of the business plan today, leaving out things that we could not do at the current moment in time. This included outreach and team information (we sent out a form for members to complete and are waiting for completion). Media finalized edits for the first recap video and gathered footage for the second recap video. Admin discussed potential awards we will submit for this season and potential nominations, including Dean’s List and Woodie Flower’s. Later on that night, we prepared the pizza dinner and ended the day with more progress on the stand-up banner.


Assembly

Field elements

We finished measuring, cutting and assembling the cube shelf, middle cone ramp, and half charge station

Field Element Progress

We tested the half charge station with our swerve drive base and robot from Deep Space. After testing, we found that the drive base interfered with the ramp and the robot was not able to drive up the ramp. We were able to figure out that the angles were slightly off from the official drawings. The actual charge station is also made of polycarb so we decided to add 2 pieces of polycarb onto one of the ramps to make the structure closer to the original and see if the wood is the one that is causing the interference.

Electrical on Prototype Bot

We made two boards that we mounted onto each side of the robot.

Components on each board:

  • Board 1: RSL, Radio, RoboRIO, VRM, PDP, Pressure Switch, Analog Pressure Sensor, and Pressure Gauge

  • Board 2: Pressure Regulator, Pressure Gauge, 2 T-Splits, Manual Shutoff Valve, PCM, and 2 Solenoids

Progress:

  • Cut peg board to size using vertical bandsaw

  • Zip tied components onto the peg board

  • Made all electrical and pneumatic connections within each board

  • Zip tied each board onto the metal posts

  • Zip tied compressor onto battery plate


CAD

Linear Actuator Claw

The intake subgroup decided to create a 1 piston intake for simplicity and weight. Thid intake had a 100% success rate with the pneumatic test bench. 10 trails each for cone and cube.

Linear Actuator Claw CAD and Assembly

Links with pneumatic test bench:

Rotational Claw CAD/Assembly

We decided to create a 4 point of contact on 4, 4" wheels, supports cones in many configurations, better grip, new cylinder placement will allow for less play (not tested with cylinders yet)

Iteration 2: cone hits the base wheel and wood arms hit first before the compliant wheels so less grip, and turning mechanism has too much play.

Iteration 3: 4 points of contacts on 4, 4" wheels, supports cones in many configurations, better grip, new cylinder placement will allow for less play.

Rotational Claw CAD and Assembly

Scissor Claw CAD/Assembly

This design is designed to have the functionality to pick the cone on its side and upright as well as to intake the cube it would get fed by the wheels and end in a diamond shape.

Scissor Claw CAD

Scissor Claw Assembly

Elevator

We spent the day CADing the first design of the elevator. We first made a place for the elevator that doesn’t bump into anything using a crayola sketch. We then created an elevator taking inspiration from our 2019 robot, Gigantor. This was our final product.

Elevator Crayola CAD

Elevator CAD

However, while consulting with our main mentor, he mentioned that the weight lighting bars will not be accurate and will take too long to manufacture. He also mentioned that the gusset that holds the bearing will only have 1 full side of bearings and 2 sides only half with bearings, making it more inaccurate. He also mentioned that we did not need to make the carriage long. Taking that into consideration, we decided to start a new iteration that will be closer to what we will first manufacture.

Sliding Gusset CAD

This was the sliding gusset that we had prototyped. This captured both sides, and the bar will be touched 12 bearings.

Arm

Decided on the design with fixed point and extending arm

Built prototype with telescope climber arm without hooks

Attached electrical panels to the sides of the upright bars


Manufacturing

Swerve

During pre-season, we CAMed the elevate and up bars (handles) for the swerve drive. This was made for easier transport of the swerve drive. We split into 2 groups (each group working on separate TM-1 CNC mills) and completed the manufacturing of the elevate and up bars. The gussets for these bars were completed prior to kickoff.

Handles for Swerve Drive

Claw

We also 3d printed and laser cut parts for the claw prototypes.

mfgprintDay2

3D-Printing for Claw Prototypes (Linear Actuator Claw)

Laser cutting for claw prototype (Rotational Grip Claw)


Programming

Vision, Arm, Claw

Today, our group had two main goals: complete the base repository (with arm and claw subsystems), and recognize April tags using Photon vision.

Our first goal of completing the base repository was quick, as most of the code was written yesterday. Today we added a method of controlling the arm using percent output and a joystick as a simpler intermediate between newly constructed hardware and motion magic control using PID. The latest version for today can be found here.

After the team-wide code review, we marked refactoring changes to be implemented tomorrow.

Our second goal of recognizing April tags using Photon vision was slightly more difficult. We were unable to open the PhotonVision dashboard and thus not letting us set a static IP address for the limelight, so we continued to use a dynamic IP address which allowed us to identify April tags and read data such as pitch and yaw.

Image of testbench setup

Image of network switch setup

Autonomous Pathing

Today, our group’s goals were to finish creating two simple auto paths (moving backwards and forwards) using tank drive. After the autos were finished programming, we did a systems check on Gigantor (our 2019 robot) so that we could ensure there were no hardware issues with the robot before testing the autos. From the systems check, we found that Gigantor’s chain was skipping. Due to this hardware issue, we were unable to test the autos.

Swerve

Today our group’s goals were to update our swerve drive code to WPILib 2023 and be able to run it on the robot. The upgrading process itself was relatively straightforward, with the only major code change being having to convert Swerve Module states into Swerve Module Positions, as in 2023 WPILib, SwerveDriveOdometry updates using Swerve Module Positions, which contain the distance travelled and the angle of one swerve module, rather than Swerve Module States, which contain the speed and angle instead.

// Old 2022 code
public SwerveModuleState getState() {
    return new SwerveModuleState(getDriveVelocity(), new Rotation2d(getTurningPosition()));
}

// New 2023 code
public SwerveModulePosition getPosition() {
    return new SwerveModulePosition(getDrivePosition(), new Rotation2d(getTurningPosition()));
}

We ran into several issues, such as there not being an official NavX library for WPILib 2023, and a strange issue where all angles were rotated by 90 degrees. We applied temporary fixes to most of these issues, as we were short on time, using an (unofficial NavX library)[GitHub - rzblue/navx-frc: Unofficial 2023 NavX FRC Library] in place of the official one and manually applying a rotation to all angles. We also tested driving onto the mock charging station that our assembly team built but we were not able to drive onto it, as the frame would hit the ramp of the charging station before the wheels were able to contact it.

January 9th Meeting

Admin

All of Admin worked on pins today. We each made a number of designs and collectively decided which ones we’d use for competitions. We concluded that we’d have competition-exclusive pins and change the design for every competition we go to. We decided to have 2 standard game-focused designs and 3-4 unique ones. We handled lunch today with Raising Cane’s and were able to distribute everything with ease. After lunch, we took inventory of fronts and backs for pins in order to decide how many we’d need for the season. We set the goal of 700 per competition, totaling 2100 for the entire season. Afterwards, we began the Admin BOM for any necessary materials we needed. Media finalized editing for the second recap video and gathered footage for the third recap video. We sent out the food order forms for next Friday and Saturday and collected some money for the first day. Some Admin members worked on the parent kick off flyer, which was to be sent out to parents with the RSVP form (since there’s limited seating). A few other members started updating the website, and some others worked on tonight’s McDonald’s dinner. Though it was rainy, we were able to easily distribute food. After, we made a few pins to show Mr. Harder along with the final stand-up banner design and parent kickoff flyer.


Asssembly

Field Elements

For the end cone ramp, we measured, cut, and finished assembling it

End Cone Ramp

Fixes:

  • Charge station / drive base – we removed a bar on the drive base that was over the wheels, allowing for the robot to go on the ramp

  • Middle cone ramp – we redid the shark fin after fixing angel measurements

Fixed Cone Ramp Shark Fin

Claw Prototypes

We had assembly members help build/work on two of the claw prototypes. We taught some of our assembly members and members from other subteams about pneumatics and how to use the manual pneumatic test bench. Using the test bench, we tested two of the claw prototypes.

Electrical on Prototype Bot

We made connections between the two boards as well as connecting our drive motors to the PDP. We also connected all our CAN wires.

Drive: 3 cim ball shifter with 3 falcon 500 motors (x2; one gearbox on each side)

Electrical on Prototype Bot

Pneumatics on Prototype Bot

We ziptied the airtank down but it had a leak, so it was replaced. Made all pneumatic connections. (Pictured above)

  • Storing Pressure: 120 psi

  • Working Pressure: 60 psi

  • Rated Tubing: ¼", 125 psi

  • Drive shifting (1 solenoid)

  • Claw open and close (1 solenoid)


CAD


This section is being updated. Please return later for more information.

Manufacturing

Swerve

With the completed Up and Elevate bar and the gussets, we assembled the handles on the swerve drive.

Completed assembly of the handles for swerve drive.

Elevator & Claw

We also 3D printed parts for the claw/intake prototypes (Elevator and Scissor Claw; respectively)

Printed elevator parts.

Printed Scissor Claw part.

Laser cut linear actuator prototype and assisted with the assembly

Other

We also 3D printed a cover for the Navx on the roborio.

Finished print of the Navx cover.

All the machines (TM-1 and the Super Mini Mills) and the vises were cleaned for Friday.

Cleaning the machines


Programming

Vision

Today, our goal was to drive within range of and align to an April tag using a tank drivebase. We began with a code review with a mentor and then merged our testbench code with the main repository: ChargedUp2023. We then referred to PhotonVision documentation to implement an aim at target method. This method used a PID loop with the error being the yaw difference between the target and limelight.

Vision Code Sample

Our implementation of distance finding between target and camera was similar: where distance was used as the error for a PID loop. After implementing this functionality using documentation, however, we found there was a high error (anywhere from 10 to 90 meters of error) when printing the distance. After manually calculating distances and ensuring the built-in equation (see below) was correct for our use case, we realized the high error was because of our low accuracy when measuring the height of the camera and the height of the limelight.

Built-in Equation

Radio Configuration

Additionally, we found that two radios we owned would not establish communications on driver station. This issue could also be seen on the indicator lights on our network switch, where the light corresponding to the radio would not turn on (see image below). This was likely because they were not configured, and a future goal is to ensure at least one of our laptops is reliable when configuring radios.

Network switch with all indicator lights off.

Swerve

Today, our goal was to finish testing swerve drive code on 2023 and begin programming commands such as turning to an angle and automatically balancing on the charging station. We found that most of our issues from yesterday were due to the encoders becoming offset. We were able to fix this by resetting the encoders to the same position as the absolute encoders, using this method:

Code sample that reset the encoders to the same position as the absolute encoders.

After fixing the program, we were able to have our driver test driving the swerve drive. We then added a low pass filter and scaled the input quadratically to make the driving more comfortable for them, using these lines of code:

Code sample for the low pass filter and scaled the input quadratically

We used both the low pass filter and the quadratic filter last year, so we used nearly the same implementation as our Rapid React code in this project.

While our driver tested the swerve drive, our assembly subteam set up their new mock charging station, which now has a layer of plexiglass on top to more accurately match the real charging station. This allowed our swerve drive to climb the charging station. After a bit of practice, our driver was able to regularly climb the charging station and park on top of it.

Afterwards, the swerve drive was given to the assembly subteam to add handles and bumpers to it. While assembly worked on the drivebase, we continued in development, writing a new command for turning to an angle based on the NavX’s readings, adding javadoc comments and more documentation to our code, and refactoring some of the classes to be more readable. After Assembly finished, we were able to drive onto the ramp even with a bumper on the robot, showing us that swerve drive may be a feasible choice for this season. However, we still need to fix much of our code, as it lacks important functionality such as in-game autonomous routines, and some functions, such as turn to angle, either weren’t tested or don’t work. We plan to fix these soon and implement them in a swerve drive auto.

Autonomous Code

Today, our goal was to finish writing up the auto commands and writing a drivetrain code that extends from the differential drive train class on WPILib. By testing on the prototype bot and Thomas (our 2020, 2021 robot), we found out that the code we wrote for the drivetrain did not work so we shifted to the code from yesterday and tested. We discovered that there were some issues with one of the Falcon motors in the drive and wrong inversions on the right side of the drive base; however, we were able to troubleshoot by using Phoenix Tuner to check what they were inverted to and editing code as needed.

Claw

We also tested the claw code and found out that we were using faulty solenoids, so we switched them out and successfully controlled the claw.

nice

Week 2 (1/13 to 1/20)

Assembly

Training

We conducted training for new members (Rotations):

  • Motor testing
    • Used phoenix tuner and driver’s station
    • Recorded motor data in a spreadsheet and labeled motors
  • Comp maintenance
  • Pneumatics
    • How to use the manual test bench
    • Layout and components of prototype bot pneumatics
  • Soldering
  • Chain Tensioning
    • Practicing chain tensioning by using wrenches to tie and loosen snail gears

Claw

Once the assembly of the double piston claw was done, we attached it to the prototype bot.

Image of the completed claw assembly

We fixed a claw prototype’s cone compression.

Demo of claw holding cone

We tested a claw prototype

  • Set up pneumatic test bench and tested the two-piston claw design. It was successful for both the cone and the cube.

We finished the assembly of the claw prototype. Upon completion, it was tested and successfully picked up and scored a cone on the node about 4 times until the wood snapped while testing.

Broken wood on claw prototype

Arm

Installed the piston on arm

  • Tubing
  • Wires

Piston attatched to claw prototype

Elevator

We also worked on the elevator prototype:

  • Worked with CAD in assembly of the elevator
  • Took inventory for elevator parts
  • Riveted U shape

The start of our elevator prototype

Cone Runner

We worked on the assembly of the cone runner intake prototype.

  • Once assembled, we tested it.

Assembled cone runner intake prototype

Video of the intake working: 2fec204ef34c4fb4be7b5f9c99bf19b9.MOV - Google Drive

Field Elements

We finished assembling the end cone ramp.
Connected the cube shelf divider beam to cone ramp horizontal beam using wood screws and spacer plywood

Image of the completed Cone Ramp.

Made a substation height simulator (Double Substation Stand)

  • Cut wood and assembled

New double substation stand

Robot Repairs/Maintenance

We did several repairs on our prototype bots such as:

  • Fixed CAN on prototype bot
  • Fixed gearboxes on prototype bot
  • We finished attaching handles onto our swerve bot.

Handles on Swerve

We fixed a Pneumatic Leak in our Prototype Bot:
We found slanted tubing, so we cut a new tube and reconnected it

Robot Cart

We continued brainstorming and designing a new robot cart. We completed the following:
After the brainstorming on Friday, we made the 1st iteration design and reviewed those designs with our advisor

CAD design of new robot cart

We continued to work on Robot Cart.

  • Got feedback from advisor
  • Created a 2nd iteration
  • Started Bill of Materials (BOM)

Two possible designs for the robot cart

Driver Station

We began work on a new driver station.

  • Assembled the base of the driver station.
  • Used the bandsaw to cut bars for the base and polycarb.

Finished driver station base

Other

We repaired the Wooden Dolley our team uses to push around large materials.

  • Replace broken plywood
  • Stapled fabric using staple gun

Fixed Wooden Dolley

We also assembled versaplanetary gearboxes for our prototype bot.

We started working on our new robot cart and driver’s station.

  • brainstorming updated designs
  • design constraints
  • additional features

We recorded inventory for the following components:

  • Cone Runner
  • Motor

Did basic battery maintenance:

  • Battery Leads: take off and replace battery leads. Use heat gun to secure heatshrink.
  • Tested 2 batteries with a computerized battery analyzer

Made changes to encoder connection (NEOs):

  • Spliced 24AWG onto 28AWG onto neo motor encoder wires

We Disassembled telescope climb to get more parts needed for other claw prototypes:

  • Bearings
  • stock

We recorded inventory for versaplanetary gearboxes.

Some assembly members had Manufacturing Training on:

  • Work offsets
  • Helping MFG with parts list
  • Facing, probing

We performed the following electrical work:

  • Prepared CANcoders for 2nd swerve

Completed encoder preparation

We helped the ADMIN sub team with the following:

  • Created FRC sponsors Stickers
  • Started design for sponsorship panels

Image of our sponsor panel layout

CAD

Telescope Arm

First cad of two stage telescope arm. Each tube is 27 inches long. Received feedback. Need to find a way to move the arm. Thinking of attaching motor to elevator carriage.

Screenshot of arm CAD

Elevator

We finished updating the elevator. Some of the updates included making the bars into 29 inches to make it easier for manufacturing. We created drawings of all the parts, and created a BOM that we must order to make the elevator.

Screenshot of elevator CAD

Rotational Claw

We then tested the rotational claw with the pneumatic piston test bench and had 100% success rate out of 10 trials with cone and cube.

Screenshot of the claw cad.

Buddy Climb

We started on the first buddy climber prototype design using pieces of plywood. Functionalities wise we wanted the swerve drive base to drive on to the structure and the T shape to hook underneath the swerve drive base wheels. We chose a T shape to accommodate the locations of the wheels of varying drive bases.

CAD and prototype of buddy climb

Polycarbonate was also added to the buddy climber prototype for stability and better testing results.

cadBuddy2

2nd itteration of buddy climb

Video: IMG_0267.MOV - Google Drive

Cone Runner

We wanted to focus on ground intake and created a cone runner design and a single angular ground intake design.

CAD model of cone runner design

Swerve Bumpers

After testing dimensions with a current swerve drive base docking and engaging we completed the swerve bumper design with technical drawings from those dimensions. We wanted to make the process of taking off bumpers and putting them back on as easy as possible. We went with a pin design with 4 c-channel mounts with two on opposite sides.

Screenshots of the drawings for our swerve bumpers

This swerve drive was previously used during the off season of 2022-2023 and now with season we had to make a few changes with the handlebar placement and crossbar placement for the future design this is to model potential configurations but is not final.

Then we created a structure for the cone runner to mount on that is 4 inches tall and 11 inches wide.

West Coast Bumpers

Moving on to west coast drive base bumpers, we completed the first design and started on technical drawings. Again, using c-channel for a pin attachment like the swerve bumpers design. Changed the c-channel placement and the wood lengths.

cadWC

CAD model of West Coast bumpers

Manufacturing

TM-1 Cleaning

The manufacturing subteam set up a 3D printer with TPU filament and another with Nylon X to test the usability of the various materials. We printed a test belt with the TPU, which proved to be successful. We also reorganized and lowered our stock rack so that we could add more shelves and create a more efficient storage area for manufacturing. Furthermore, the side guards on the TM-1 were removed in preparation for the elevator bar. The TM-1 vises and work surface, as well as the side guards, were vacuumed and cleaned with oil.

*A close-up of the tidied bare TM-1 work surface. *

A full shot of the TM-1 with its guard railing removed.

A selfie shot of the people who busted their butts and worked through approx. 10 machine cloths to get this baby nice and shiny.

*A full shot of our cleaned guard railing with its screws and washers (for connection to the TM-1) taped on to ease reattachment + the tips of my feet (how scandalous). *

Gussets & Bars

At the beginning of the day, half of the manufacturing subteam helped disassemble the hangar from last year’s game while the other half reviewed the completed elevator CAD drawings. After some modifications in the gussets, the drawings were approved for manufacturing. The parts were first divided into which CNC mills they would be manufactured on and then divided into groups regarding their plate thickness (gussets). We completed all of the bar CAMs and are almost done with the gusset CAMs. The stock was also cut in preparation for facing (bar length + .25 in).

Picture of the completed CAM for the .125 gussets

On January 16th, the manufacturing subteam began facing the remaining bar stock and finalizing the CAM for the gussets. However, there was some miscommunication regarding the thickness of the gusset plates, so the gussets were reCAMed. However, the original .0625in plate gussets (P407 – qt8, P408 – qt4, P414 – qt2) were completed by the end of the meeting and bandsawed off the plate. 4 bars were completed by the end of the meeting (P401 – qt2, P406 – qt1, P409 – qt1).

Completed plate with corner gussets - P407, bot motor gusset - P408, and backrest gusset - P414

Completed bars (base up bar - P401 , carriage beam - P406 , bot rail – P409)

On Thursday, all the bars for elevator (except for top support rail) were completed and the mini mill was set up to run the remaining .0625 parts.

During a worktime of approximately 90 minutes, manufacturing sanded and buffered the previously manufactured gussets. They were then chamfered on both sides, but the team then found that the reaming program for the gussets were too shallow and did not allow for some holes to fit a rivet. To ensure that all holes could be riveted, we deburred the faulty holes. However, we discovered our error in the CAM when the bottom height of the reamer was due to the program not acknowledging the reamer tip in “drill tip through”. Thus, in future parts, we have fixed this issue and the reamers fit.

Our completed sanded, buffered, and chamfered gussets.

One sheet of .0625 gussets were manufactured with the intent to be doubled to .125 gussets (as we had run out of 1/8 alum sheets). Members learned how to bandsaw round edges of the gussets through relief cuts. However, due to the change in CAD design, manufacturing gussets was put on hold. Instead, we CAMed a program to drill shoulder screw holes into new 1/16 sheets of aluminum so that they could be manufactured on our tooling plate.

MFG members hard at work

Gussets for another swerve drive were CAMed and dry run on the mini mills, but not manufactured due to a shortened meeting time.

Organization of Stock Rack

Reorganized stock rack

Programming

Vision Group

This week, we learned that there are two methods of determining the robot’s distance from the april tags using the Limelight. The first method uses the angle and the height of the camera along with the angle and height of the april tag to determine the distance from the camera to the target. It also uses the angle from the Limelight to the target which is the value that is changed to help determine the distance between the Limelight and april tag. However, if the numbers were slightly off, then the distance would be changed exponentially. That is why we decided to go with the second method that uses the area of the Limelight which the target takes up. To do so, we had to find an equation to determine how the area of the target relates to the distance between the Limelight and the april tag. We tested the turning using the pitch received from the Limelight, and it was successful

Auto Group

First, we continued testing the drive and claw functionalities of the prototype bot. For the sides of the drive base that had an unused motor, the motor current ramped up to around 178 amps. The removal of the motor resulted in the motor current ramping up to only around 30-40 amps, which is a safe amount. Next, we tested autos that drove straight and faced a certain angle using a NavX, but they need further PID tuning. We have also tested several buddy climb iterations. There were some successful trials; however, the swerve drivetrain was unable to stay on the buddy climb for most trials.

Swerve Group

This week, we worked on adding smaller features to our codebase.

First, we transferred some of the swerve commands we had written, such as turn to angle using the gyroscope and charge station balancing, to be compatible with a west coast drivetrain, as at this point, we were not sure which drivebase we would be committing to.

After that, we worked on adding logging to the robot, first testing using the WPILib DataLog framework on a testbench, and then writing code to implement it into our subsystems. We hope that this will solve some of our slowdown issues from last year, when we used BadLog for logging, as DataLog does I/O operations on a separate thread, which should reduce slowdown.

public static void init() {
    // Old logging code
    createTopic("LeftMaster" + "/Voltage", () -> robotContainer.drivetrain.leftMaster.getMotorOutputVoltage());
    createTopic("RightMaster" + "/Voltage", () -> robotContainer.drivetrain.leftMaster.getMotorOutputVoltage());
    createTopic("RightFollower" + "/Voltage", () -> robotContainer.drivetrain.rightSlave.getMotorOutputVoltage());
    createTopic("LeftFollower" + "/Voltage", () -> robotContainer.drivetrain.leftSlave.getMotorOutputVoltage());

    createTopic("LeftMaster" + "/Current", () -> robotContainer.drivetrain.leftMaster.getMotorOutputVoltage());
    createTopic("RightMaster" + "/Current", () -> robotContainer.drivetrain.leftMaster.getMotorOutputVoltage());
    createTopic("RightFollower" + "/Current", () -> robotContainer.drivetrain.rightSlave.getMotorOutputVoltage());
    createTopic("LeftFollower" + "/Current", () -> robotContainer.drivetrain.leftSlave.getMotorOutputVoltage());

    ...
}

@Override
public void robotInit() {
    // New logging code (logs everything from networktables)
    DataLogManager.start("/lvuser/logs/");
    DataLogManager.logNetworkTables(true);

    ...
}

Week 3 (1/21 to 1/28)

Assembly

1/21 - Saturday

Driver station

  • Added 2 1x1 handlebars onto the base for the Velcro

Images of Driver Station assembly progress

We reinforced the claw prototype by doubling the wood pieces and adding gussets in between the wood to have more support.

Finished Reinforced Claw Prototype

We did maintenance checks on screws and falcon motors.

We started working on swerve bumpers.

We continued work on the Robot Cart and Sponsorship panels.

  • Continued to design and finalize the sponsorship panel
  • Continued iterating CAD for the robot cart

1/23 - Monday

Driver station
Changes were made to the Driver station after receiving input from drivers and technician.
We cadded new:

  • Frame
  • Cable management
  • Laptop and controller placements

Possible design # 1

Possible design # 2

Robot Cart

A new design for the robot cart was Cadded. Once it is done, it will be checked with the advisor for approval.

New Robot Cart Design

Sponsorship Panels
We completed the new sponsorship panel design and got it approved by Mr. Harder.

  • Reoriented from vertical to horizontal

(add image)

New Sponsorship Panel Design

We fully assembled all the new swerve modules

(add image)

Completed Swerve Modules

We tested all our falcon motors.

  • We documented all of the data
  • Made a guide on how to test falcons for future reference

Links:
How to test falcons:
Spreadsheet Falcon Data:

We also helped CAD with drilling and assembling the linear claw iteration.

We finished assembling swerve bumpers.

(add image)

Finished frame for the swerve bumpers.

CAD

Manufacturing

Programming

Vision Group

1/23

We got the April Tag and Object Detection to work on a single limelight. The 4 objects being the cones, cubes, tape, and April Tags. Our code allows us to have the robot drive toward a target object while also making any angle corrections along the way.

prgVision1

Later in the day, we refactored the aimAt_Object_() methods into one aimAt() method which allows the code to choose to target any of the 4 object types in one line only by entering in an enum: “CONE”, “CUBE”, “TAPE”, “TAG”.

public static enum TargetType {
   CONE,
   CUBE,
   TAPE,
   TAG 
}

The object detection works so well that we can tape an object to a moving person and have the robot chase them around completely autonomously. As an extra feature, we implemented a move back algorithm which has the robot drive backwards if the object were to get too close.

1/27

We worked on implementing vision with the swerve drive. We did this by creating a command that combined the turnToAngle command and the driveToTarget command. We were able to test our code on the actual swerve drive, but it didn’t work. One of the possible errors was that the PID values needed to be tuned a little bit.

prgVision2

DriveToTarget testing, robot oscillated in place

1/28

We refactored our code for vision with the swerve drive. We switched the xSpeed and ySpeed values because the y and x axes are switched.

Tested the previously broken limelight and it works now. Also reflashed the limelight with photonvision firmware to have limelight firmware.

Tested our refactored code. The code seems to work but the values were flickering because the limelight was wavering between not detecting the apriltag and detecting the apriltag. So, we need to tune the limelight more.

prgVision3

Previously broken but now functional limelight

Swerve Drive Group

This week, we worked on writing and testing auto paths.

First, we tested a simple auto path that moved in a 1-by-1 meter square. While testing, we found that our odometry calculations were incorrect and were missing compensation for the swerve modules’ gear ratio. After adding the gear ratio into the calculation, we found that the auto path worked relatively well, although it was not accurate over long distances on concrete.

Afterwards, we tested a longer auto that started on the right side of the field, “scored,” picked up a game piece, “scored,” picked up another game piece, “scored,” and then went to the charging station. We found that this auto worked relatively reliably on carpet but took too long to run. Even after increasing our max velocity and acceleration for the auto, we found that we could not score the third game piece in time.

During driver testing of the swerve drive, they suggested adding a stow command, which turns all wheels to a 45-degree angle to make the swerve drive impossible to move, as well as adding turn to 0- and 180-degree commands to the driver controls, as this gave them easier maneuverability. After implementing these commands, we tuned the PID values on our swerve modules’ turning motors, as they were overshooting before. We used the live graphs from AdvantageScope in order to tune the PID.

Lastly, we then tested integrating our balancing command into the auto. We created a new auto that directly went to the charging station, and then tested it on our charging station mockup. We found that, although it worked, the charging was slow due to us not having a separate P-gain value for initially climbing up the ramp.

prgSwerve1

Because of this, we modified our auto to have two stages for the charging: one with a higher P-gain for going up the ramp, and one with the original P-gain for balancing once on the charging station. We then tested stowing the wheels at the end of the command but found that it was unreliable and sometimes would even cause the swerve drive to slowly slide off the ramp.

public class TimedBalancingAct extends SequentialCommandGroup {
    public TimedBalancingAct(SwerveDrivetrain swerveDrive, double period1, double kP1, double kP2) {
        super(
            new ParallelRaceGroup(
                new WaitCommand(period1),
                new TheGreatBalancingAct(swerveDrive, kP1)
            ),
            new TheGreatBalancingAct(swerveDrive, kP2)
        );
    }
}

Our timed balancing command

Tank Drive Group

On Saturday, 1/21, we made naming conventions for certain positions and components on the field to make identifying auto paths easier. We also made code names for each of our auto paths.

prgTank1

Hard Carry Auto Path

prgTank2

Diet Coke Auto

prgTank3

Overpriced Vending Machine Auto

We debugged the autonomous code to make the robot accurately turn to the degree input in the code and made the robot move backwards and forwards a specific distance with accuracy.

We also wrote code for the cone runner and the rotating arm.

Week 4 (1/30 to 2/4)

Assembly

1/30 - Monday

Robot Cart

  • We finalized our BOM for Robot Cart and finished ASM drawings.
  • Finished Drawings but still need it to get approved
  • Started Measuring Wood (Preparing to cut)

Pneumatics

  • Set all regulators to 60 psi
  • Helped test claw iteration with pneumatic test bench
  • Tested Solenoids
  • Did Training on regulators

We continued to work on the new bumpers.

  • We attached the pool noodles to the wooden base
  • Laid out the fabric and began to staple it in place

bumpers

Bumpers with fabric set up.

2/3-Friday

Robot Cart

  • We started measuring and cutting wood for Robot Cart
  • We rediscussed with our advisor and decided to redesign our robot cart (table portion) using Milwaukees for storage

Arm and Claw

  • We adjusted the regulators on both the arm and the claw
  • We tested the next iteration of the claw

Pneumatics

  • We tested solenoids

Intake

  • We finished mounting the intake onto the robot

Bumpers

  • We readjusted the holes for C-channels and reattached the C-channels, pool noodles, and fabric
  • We finished the swerve bumpers and tested them on the actual swerve

bumpers2

Bumpers on the actual swerve.

bumpers3

Members using the staple gun to attach fabric to bumpers.

bumpers4

Members working on the bumpers.

Swerve

  • We removed the crossbeams from the swerve drive base.

2/4-Saturday

Robot Cart

  • We adjusted the table height with the Milwaukees
  • We finished the CAD of the robot cart
  • We cut the upper support bars for the cart
  • We added to the Robot Cart BOM
  • We decided on custom décor ideas to add to the cart

Cone runner

  • We added the electrical connections to the cone runner

Pneumatics

  • We switched the pneumatics on the prototype robot

Bumpers

  • We attached the numbers to the bumpers

Repacking

  • We remade the mechanical list and double-checked the electrical packing list

CAD

Elevator Group

We Continued to work on the write up/ procedures for the Elevator assembly. This guide serves as a manual for assembly and a way to increase the ease of Assembly and speed up the overall assembly process.

Elevator Assembly Guide: 687-23-A400G-ELEVATOR ASM GUIDE - Google Docs

We realized that we might not have enough spacers for the elevator. After getting the number of spacers we need for the elevator, we counted the ones we have. We decided to 3D print the spacers necessary.

NavX Covers

We finalized and printed the NavX Covers.

navXPrint

Printing the NavX Cover

navXCover

Picture of the NavX Cover

Buddy Climb

We worked on finalizing the Buddy climb CAD and drawings. The Buddy climber drawings got checked during this meeting by Kloe and James Cozatt.

buddyclimbcad

Buddy climb drawing

gussetcad

centerbarcad

mountingbarcad

We added accessibility windows to the horizontal bar that allows us to screw in the polycarbonate onto the bar from the side.

centerbarcadrender

CAD of the horizontal bar

Battery Plate Group

We realized we needed to CAD a new battery plate because the side did not fit as we were making the gap between the two bars from 7 inches to 11 inches. We decided to have a place for battery as long as the compressor.

The CAD of battery plate has been finalized.
Drawings of Battery Plate have been finished and are ready for approval.

batteryplaterender

CAD of the Battery Plate

Side Notes

1/30/23

Joyce:

We fixed some gussets and changed the diagonal bar because there was too little space for the batteries. We also did some drawings.

Kloe:

We adjusted the angles and wheel positions of rotational claw. We created a parts list for Linear claw and then we Lasercut all the Polycarbonate parts. Finished the drawings for West Coast bumpers.

2/3/23

Joyce:

We helped assembly with robot Cart. We also discussed with Assembly about what they believed that the ideal table cart height should be. To reach 41 inches, we decided to ad 2x4s to the bottom.

Kloe:

We completed the Linear Claw Assembly and tested the Linear claw.

Joyce:

Worked on motor mount placement, cad, and drawings. Helped assembly with electrical placement. Assisted navx cover prints

Manufacturing

1/30

Our mini mill was prepped to manufacture gussets, but it was decided that the CADs would be redone. Instead, we bandsawed polycarbonate parts for CAD prototypes.

The polycarbonate parts

2/2

On Friday, we finished facing all the stock for the bars, and manufactured the bud gussets.

budgusset

The bud gussets

2/3

A gusset plate that was previously manufactured for RL elevator was band sawed, sanded, buffered, and deburred due to the reaming program being too shallow. Afterwards, another plate of gussets (1.5x1 gusset and top gusset) for pivoter were made, bandsawed, and sanded, but not yet buffered or chamfered. Furthermore, the studs, crossbeam (swerve drive), and crossbar for the pivoter frame was completed. For the remainder of the meeting, we cleaned up the machine shop and cleaned the chips from the machines.

budgussets

The bud gussets

millingmachine

The milling machine

Programming

Vision Group

We changed the driveToTarget command to be able to drive to any type of object(Cube, Cone, Tape, Tag) and we made new sequentialcommandgroups. We made one for getting an object and one for scoring an object.

public class CommandsThatImplementDriveToTarget {
    public class getGameObj extends SequentialCommandGroup{
        public getGameObj(SwerveDrivetrain drivetrain, Limelight limelight, Arm arm, Claw claw, PipelineType pipeline){
            addCommands(
                claw.clawOpen(),
                arm.moveArmScore(),
                new ApproachCombined(drivetrain, limelight, 2, pipeline),
                arm.armExtend(),
                claw.clawClose(),
                arm.armStow()
            );
        }
    }
    public class scoreObj extends SequentialCommandGroup{
        public scoreObj(SwerveDrivetrain drivetrain, Limelight limelight, Arm arm, Claw claw){
            addCommands(
                arm.moveArmScore(),
                new ApproachCombined(drivetrain, limelight, 2, PipelineType.TAPE),
                arm.armExtend(),
                claw.clawOpen(),
                arm.armStow()
            );
        }
    }
}

We also created a class for the AirCompressor as it is used in several subsystems and has an analog output to be logged.

public class AirCompressor extends SubsystemBase implements Reportable {
    private Compressor compressor;

    // Pressure sensor is connected to analog port on RoboRIO
    private AnalogInput pressureSensor = new AnalogInput(PneumaticsConstants.kPressureSensorPort);

    public AirCompressor() {
        compressor = new Compressor(PneumaticsConstants.kPCMPort, PneumaticsModuleType.CTREPCM);
        compressor.enableDigital();
        // compressor.disable();
    }

    @Override
    public void periodic() {}

    public void reportToSmartDashboard() {
        SmartDashboard.putNumber("Air Pressure", pressureSensor.getValue());
    }
}

Subsystems Group

We worked on two different versions of position control for the arm.

The first one is through pure PID control using the PIDController class and brake mode to compensate for the gravitational pull.

public void moveArm(double position) { 
    armPID.setSetpoint(position); 
    double speed = armPID.calculate(rotatingArm.getSelectedSensorPosition(), position); 
    if (speed > 3000) { 
        speed = 3000; 
    } else if (speed < -3000) { 
        speed = -3000;
    } 
    rotatingArm.set(ControlMode.Velocity, speed); 
    if (armPID.atSetpoint()) { 
        rotatingArm.setNeutralMode(NeutralMode.Brake); 
    } else { 
        rotatingArm.setNeutralMode(NeutralMode.Coast); 
    } 
} 

The second method is through motion magic.

public void moveArmMotionMagic(int position) { 
    // config tuning params in slot 0 
    rotatingArm.set(ControlMode.MotionMagic, position, DemandType.ArbitraryFeedForward, Math.cos(position * ArmConstants.kAnglePerTicks)*ArmConstants.kArbitraryFF); 
    this.targetTicks = position; 
} 

For the motion magic method, it was necessary for us to figure out how to find the current angle.

Swerve Group

This week, we worked on maintaining our codebase. We merged most of the branches in our Github repository into our development branch, and then merged the development branch into the main branch. We then created a release of our code. Afterwards, we deleted all of our unused branches.

After the release, we worked on minor refactoring changes, such as moving default command assignments to their own methods and centralizing our SmartDashboard calls. To enforce the implementation of the reportToSmartDashboard() method in our subsystems, we created the interface Reportable and implemented it in all of the subsystems.

The reportable interface:

package frc.robot.subsystems; 

public interface Reportable { 
    public void reportToSmartDashboard(); 
}

Our new, centralized reportAllToSmartDashboard() method:

public void reportAllToSmartDashboard() {
    // SmartDashboard.putNumber("Timestamp", WPIUtilJNI.now());
    imu.reportToSmartDashboard();
    claw.reportToSmartDashboard();
    arm.reportToSmartDashboard();
    coneRunner.reportToSmartDashboard();
    if (IsSwerveDrive) {
        swerveDrive.reportToSmartDashboard();
        swerveDrive.reportModulesToSmartDashboard();
    } else {
        tankDrive.reportToSmartDashboard();
    }
    airCompressor.reportToSmartDashboard();
}

We also created diagrams on how our implementation of Swerve Drive works, in order to document it for the rest of our subteam.