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:
Team Resources:
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:
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.
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)
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.
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 |
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
Created crayolas of possible first iteration arm designs
Analyzed pros and cons of each design
| Pros | Cons |
|---|---|
| Simple first iteration | Center of gravity |
| Unstable | |
| No high scoring |
Crayola CAD of telescope arm at an angle on Day 1
| Pros | Cons |
|---|---|
| Simple and effective | Very Heavy (arm is very long) |
| Center of gravity |
Crayola CAD of Telescope arm on an elevator on Day 1
| Pros | Cons |
|---|---|
| able to quickly score in all rows | Multiple telescope stages |
| Arm is heavy and suceptible to collisions | |
| Complex |
Crayola CAD of pneumatic arm on Day 1
| Pros | Cons |
|---|---|
| Extremely simple | Unstable |
| Mid scoring only |
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.
We made a new repository for 2023 and began writing the Drivetrain subsystem, as well as the auto using tank drive.
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.
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
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.
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.
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.
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
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:
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
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
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.
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
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
We also 3d printed and laser cut parts for the claw prototypes.
3D-Printing for Claw Prototypes (Linear Actuator Claw)
Laser cutting for claw prototype (Rotational Grip 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
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.
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.
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.
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
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.
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
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)
This section is being updated. Please return later for more information.
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.
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
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
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
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.
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.
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.
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
We conducted training for new members (Rotations):
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
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
Installed the piston on arm
Piston attatched to claw prototype
We also worked on the elevator prototype:
The start of our elevator prototype
We worked on the assembly of the cone runner intake prototype.
Assembled cone runner intake prototype
Video of the intake working: 2fec204ef34c4fb4be7b5f9c99bf19b9.MOV - Google Drive
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)
New double substation stand
We did several repairs on our prototype bots such as:
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
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.
Two possible designs for the robot cart
We began work on a new driver station.
Finished driver station base
We repaired the Wooden Dolley our team uses to push around large materials.
Fixed Wooden Dolley
We also assembled versaplanetary gearboxes for our prototype bot.
We started working on our new robot cart and driver’s station.
We recorded inventory for the following components:
Did basic battery maintenance:
Made changes to encoder connection (NEOs):
We Disassembled telescope climb to get more parts needed for other claw prototypes:
We recorded inventory for versaplanetary gearboxes.
Some assembly members had Manufacturing Training on:
We performed the following electrical work:
Completed encoder preparation
We helped the ADMIN sub team with the following:
Image of our sponsor panel layout
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
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
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.
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.
2nd itteration of buddy climb
Video: IMG_0267.MOV - Google Drive
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
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.
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.
CAD model of West Coast bumpers
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). *
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.
Reorganized stock rack
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
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.
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);
...
}
Driver station
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.
Driver station
Changes were made to the Driver station after receiving input from drivers and technician.
We cadded new:
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.
(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.
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.
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.
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.
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.
DriveToTarget testing, robot oscillated in place
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.
Previously broken but now functional limelight
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.
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
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.
Hard Carry Auto Path
Diet Coke Auto
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.
Robot Cart
Pneumatics
We continued to work on the new bumpers.
Bumpers with fabric set up.
Robot Cart
Arm and Claw
Pneumatics
Intake
Bumpers
Bumpers on the actual swerve.
Members using the staple gun to attach fabric to bumpers.
Members working on the bumpers.
Swerve
Robot Cart
Cone runner
Pneumatics
Bumpers
Repacking
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.
We finalized and printed the NavX Covers.
Printing the NavX Cover
Picture of the NavX Cover
We worked on finalizing the Buddy climb CAD and drawings. The Buddy climber drawings got checked during this meeting by Kloe and James Cozatt.
Buddy climb drawing
We added accessibility windows to the horizontal bar that allows us to screw in the polycarbonate onto the bar from the side.
CAD of the horizontal bar
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.
CAD of the Battery Plate
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.
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
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
On Friday, we finished facing all the stock for the bars, and manufactured the bud gussets.
The bud gussets
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.
The bud gussets
The milling machine
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());
}
}
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.
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.
This topic was automatically closed 365 days after the last reply. New replies are no longer allowed.
