Author: Ria G. & Caitlyn Mei R.
Witness: Ms. Maria Osoria and Ms. Manisha Shah
Date: 10/7/20
Duration: 5:00 - 6:30
Ahmed Mahmud
Manyata Arora
Amanpreet Dhah
Hooryah Raja
Murtaza Raja
Martin Soliman
Martina Soliman
Syed Shah
Benjamin Fitzgerald
Caitlyn Mei Roxas
Arleen Dhah
Atharva Khandelwal
Abrahim Mahmud
Abriti Chatterjee
✅
✅
✅
✅
✅
✅
✅
✅
✅
✅
✅
✅
✅
✅
Anirudh Chaturvedula
Astrid Salazar
Ehtesham Suhail
Lutfiyah Mohammed
Prajwal Khanal
Ria Gray
Shaurya Singh
Sivaditya Padmanabhan
Tvisha Doshi
Vanisha Rajlakshmi
Ved Borade
Venya Goyal
Yuga Patel
✅
✅
✅
✅
✅
✅
✅
✅
✅
✅
✅
✅
✅
The programming team is able to make our first autonomous that we plan to use as a base when writing more programs for the challenge this year.
The program should go to target zone A, go to where the rings are, then park on the white line.
The specialty parts team works on downloading various parts from the GoBuilda website onto OnShape.
The robot design team works on mounting the rhino wheels onto an axle with clamping collars, and also works on planning out how we'd assemble parts of the robot.
The programming team is able to work past initial confusion and create an autonomous program.
We use RoadRunner techniques and trigonometry to find the coordinates we needed the robot to go to and added the appropriate lines of code to the program.
In the future, we want to add temporal markers to our program to account for the time it'll take the robot to shoot the rings.
The specialty design team is able to find a new way to import parts onto OnShape, and plans to download more parts onto OnShape that will be necessary for the robot.
The robot design team is able to figure out which bearings are needed in order to secure the axles to the U-channel. We plan on attaching the sprocket and the chain to the axle.
The robot design team and the specialty parts team are able to work on importing necessary parts for the robot onto OnShape, like the gecko wheels and also the bumper for the robot.
The robot design team have a few things planned for today:
Mounting the rhino wheels onto an axle with clamping collars
Planning how we would secure the axle to the U-channels and looking at what bearings should be used
The specialty parts team's agenda for today include two tasks:
Downloading the Gecko Wheels from the GoBuilda website into Onshape for use by the Robot Design Team
Helping the Robot Design Team with getting the bumper parts onto the main robot design document
Robot Design Team:
We are able to use clamping collars to mount the rhino wheels onto an axle. This is our first time doing this, so it is not completely accurate. It simply serves as a model of the actual assembly.
Because we run into complications with OnShape (technical issues), only some of us are able to load the assembly.
During today's meeting, we are also able to plan out the way we wanted to secure the axle to the U-channels. We are looking at different bearings and finding the ones we need.
In the future, we plan on attaching the sprocket and chain to the axle. We also want to work out the placement of the next set of wheels.
Specialty Parts Team:
Today, we are able to download the Gecko Wheels into OnShape by exporting the files since it was a zip. We run into a couple of problems while trying to get the bumpers onto the actual document with the robot. The first problem we run into was not being able to insert the Bumper CAD into the assembly. After scouring the internet, we figure out that the CAD was imported as a mesh, making it a reference for any other part we were designing. The solution to this is to recreate the part in OnShape using the imported CAD as a reference just like it was meant to be.
One other thing that we are able to do was to work with the robot design team to get the bumpers onto the main robot design document.
In the future, we plan on downloading more parts that are necessary for the robot, as well as fix the problem with the bumper and get it onto the actual document.
This is a picture of the rhino wheels that were attached onto an axle with the use of clamping collars. This serves as a model of the actual assembly, as it is not completely accurate.
This is one of the gecko wheels that we imported from GoBuilda onto OnShape. We worked on converting the gecko wheel from a mesh to a complete part. In doing so, the robot design team would then be able to utilize the part.
The main goal for today is to make our first autonomous program for the FTC challenge of this year.
The program should have the robot go to a certain block, go to where the rings are, and then park at the white line.
We should've been able to use the most efficient methods to create the autonomous.
Although we have some confusion at the beginning, we are able to ask each other and resolve them, allowing our autonomous to do all the basic things that we were asked to do.
We do a lot of math and find out the coordinates of different points which we need to do our program.
We also add different methods that could do the tasks which were asked of us and incorporated a lot of RoadRunner techniques into the program
We add some lines of code which make the robot go from the starting position (-62, -50) to the “A” block (10, -60), then to the place where the rings are (-23, -36), and then to the white line (10,-36), making sure to take into account the heading of the robot.
Some additions we want to make to our program are adding temporal markers.
Temporal markers are a specific type of marker you could put into your RoadRunner program. They allow you to tell the program how long each movement should last.
Implementing this into our code will allow us to make the robot turn to face the powershot and shoot for a specific amount of time, instead of just speeding through all the movements. This will allow us to be more accurate/precise.
This is what we used to plan out the points we wanted the robot to go to. We start with (-62, -50) and go to push the wobble goal into configuration A at (0, -60). Then we go where we want to shoot the rings at the power goal, (-23, -36) with a heading of 12.88°. Finally, we end the autonomous by parking on the white line at (10, -36).
This is the code itself that we wrote to have the robot do what was shown in the RoadRunner plugin. We start by establishing where the robot is at the start of the program. Then we create a new trajectory named “trajectoryA1Red” that goes to the points we established earlier. We wait for start, tell it what to do if we hit stop, then tell the robot to follow trajectoryA1Red.