nobles robotics robot

this devlog tracks time from our second qualifier to states
we were first in qualifers at our second qualifer (basically events have qualifier matches then playoffs), we were 2nd place in the playoffs because our robot randomly turned off during our final match (:/)

my ship log will track changes made during states and the outcome there

major changes:

• modular auto
• on-the-fly setting changes to customize the auto
• further automation + testing (of several different control strategies)
• improved PID controllers

lots of bugs squashed

• occasionally there would be different starting conditions as static variables are preserved between runs leading to some interesting behavior
• using sequential commands in rapid succession would sometimes cause the program to crash (oops)
• various other fixes

our robot is the one on the bottom right (red 20748)

• Wrote an autonomous procedure and tested it (see attached video): the robot is controlling itself!

• Decreased looptimes from 60ms down to 10ms (through a variety of optimization strategies, mainly caching motor powers, bulkreads, not reading from more devices than when absolutely necessary, and not writing to more devices than when absolutely necessary) + added logging for looptimes

• Changed lots of keybinds

• Added more automation and fixed previously broken automation

• Refactored lots of code to prepare for autonomous control of the robot

new methods

• to spin to intake position
• to spin to outtake position
• automation for various things
• heading lock (to auto aim at the goal)

attached is a video of the auto intake + auto shoot (it’s pretty fast 🔥)

did some more testing in order to add some distance tracking and also did some autonomous planning

pretty uneventful, added some more verbose logging for a motor encoder + did some more testing around with a limit switch

worked on refactoring sooooo much, unspaghetti coded a ton of the project + did some setup for whenever the hardware catches up

also added an alliance manager component (basically in competition there are RED and BLUE alliances and you get randomly assigned). There are various things that need to update if we’re RED or BLUE, so now we can set that!

diff: https://github.com/Nobles-Robotics/20748-Decode/compare/main%40%7B3day%7D...main?diff=split&w

not very exciting but needed to be done :(

I am the lead programmer for my First Tech Challenge team. Our robot picksup balls and launches them at a goal. This devlog runs up until our first qualifier (I forgot to post devlogs before this, so this is insanely large, but there are VERY frequent commits in the repository + I plan to post devlogs more frequently after this, woopsy, and I needed to start somewhere so that future devlogs aren’t so egregiously large).

this devlog is accurate up to the code in the branch freeze/qual1 on https://github.com/Nobles-Robotics/20748-Decode/tree/freeze/qual1

What I worked on:
Drive (4 motors + mecanum wheels, which basically is a form of movement that allows turning while moving; however, this makes the code a little more complex)

• A heading lock to always face one corner of the field (based on encoder data supplied by odometry wheels + onboard calculations (inverse tangent of x and y to determine angle))
• Autonomous control using an external library

Intake (Motor + spinning wheels to pick up balls)

• basically 3 states -> either the motor is spinning forward, stopped, or backward

Storage (Motor + space to store 3 balls)

• 2 commands (run to intake + run to intake, using data from the motor encoder to properly calculate turns of 120 degrees (empirically measured as ~186.66 ticks per 120 degrees))
• Challenge: the motor encoder isn’t very accurate and after a lot of thinking one way to run this was to run to intake positions clockwise, and outtake positions counterclockwise, that way the error atleast doesn’t accumulate and atleast stays constant throughout the course of a match (the intake and outtake are on opposite sides of the robot ie. offset by 180 degrees so some basic math is sufficient to determine the ticks to next position)

Outtake (Motor + flywheel)

• 2 commands (spin up to 2100 ticks/s using a PIDF controller (Proportional Integral Derivative Feedforward and run down to let the flywheel, well, run down and stop)