January 28, 2011 Meeting

Today we finished our rennovation of the arm by changing the design to fix it due to a motor burning out again. This included a new gripping system, with two servos. Pictures of the new
design are coming soon.

January 23, 2012 Practice

On this practice we began to remodel the arm for the second competition. This included redoing the grip system and the whole arm position. We also worked out smaller issues, like moving the Samantha Module. And finally I confirmed that the autonomous programs work with our new design.

January 21, 2011 Meeting

Today, only I was present to work on the robot to prepare for the second competition we are attending. I worked on moving the arm controls downward in the robot, as well as beginning to remodel the hand. This will allow a more controlled lifting of balls and crates to the lift, improving accuracy and score.

I also worked on adding a system that will help guide the bowling ball to the robot, instead of involuntary releasing the ball. This will help us score more during the autonomous stage of the code. The position required for the internal side of the board was finally found, which was in the middle of the internal side with the robot shifted right at a 45 degree angle.

This was a productive construction day, which will help our entire team score better and hopefully make it to the state competition.

December 3, 2011 Practice

In our recent practice, we completed a lot of work with the autonomous program and making bug fixes in the joystick-control program. I added precise turning and driving, and I am planning on incorporating the infared sensor in a more precise method. Jaret and Ian started to incorporate dual joysticks, as they are used in that fashion in the competition. Jared worked on catalog the robot part, part by part.

November 26, 2011 Practice

Today, Ian eas not present, but we still accomplished a large fleet of innovations. Jared worked on finalizing the arm, even though there is still work to be done. As I encountered problems with my program, Jaret debugged the code and spent the remainder of the practice simplifing the code. Wheras after Jaret took over programming, I started the proccess of cataloging the robot parts. The current count is posted below (not complete):

43 Cm Channel - 2
29 Cm Channel - 12
Motor - 4
Servo - 2
4.75 Cm Radius Wheel - 4
5 Cm Radius Gear - 3
2 Cm Radius Gear - 7
3 Cm Radius Gear - 5
Servo Controller - 1
Motor Controller - 2

November 12, 2011 Practice

Today we woked mostly on our robot design. We did some work with our arm by attatching and reworking with the design, like working with weight-related issues. The weight of the servo could not lift the basket. We also started our lift system by attatching it to the robot. We referanced our designs to online videos with Jaret leading on the innovation. I worked on programming the arm autonomously and with the joystick. Today was considerably productive.

November 5, 2011 Practice

As our practice began, Ian and Jared began with building as usual. Wheras I was programming and Jaret was working on our shirt design.

Jared and Ian both worked on a wheel guard system, until Ian branced off and worked on a lift system for the crate.

After I encountered some joystick issues while programming, Jaret took over with his knowledge of the joystick. He did not acheive much with the program.

After my programming was taken ovey by Jaret two-thirds into the meeting, I wrapped up Jaret's shirt design using some photoshop techniques I know.

In conclusion, our meeting was mostly productive and we are looking forward
to our future meetings where we can perfect work we did today.

october 22, 2011 practice

Today we made some good progress. Jared worked on his claw and came close to finishing it. Tyler made a turning program that because of our new wheel system could turn the robot in a very confined space. Ian worked on and finished the new wheels that include 4 wheel drive with Jaret's help. Jaret continued with the joystick. The joystick is working so much better because of the 4 wheel drive system.Videos that show what we can do with four wheel drive are above.

October 3, 2011 Practice

Today, we worked with motors to create a stop on stall program due to burning out two motors. We finnaly have a system that stops the motors before they burn. We just need to spend five minutes to incorporate this into our programs, and then we will save the "lives" of many motors.

A picture of our stall test system is below.

September 26, 2011 Practice

Today, Jared and Ian were building their attachments of an elevator and the arm. I helped attach the arm and began programming for arm usage in the autonomous code. We all watched Jaret debug his joystick program "JoyOS". We made a great deal of progress today.

September 19, 2011 Practice

The interior of our robot, or
as Jared calls it, the tech package.

Tonight we finalized our driving system for our robot. We finished adding wires for motor controllers and then mounted the NXT. We then took the time to add the Samantha Module for Wi-Fi usage with the NXT. We did not get a chance to experiment with the new device.

We did get to get an atonomous program to use a simple driving pattern. I am planning on adding some simple behind-the-scenes functions that influence major functions. We will also add sensor inputs.

Jaret also started his joystick and got his program to move forward and stop the wheels. We had a very productive meeting today.

September 17, 2011 Practice

Jaret working with the
new joystick

Today, we started replacing the school's Tetrix parts with our own components. We also started to modify the robot to fit the challenge.

Some of the changes included re-creating the motor an servo controllers, along with the very important battery pack. We also started creating new joystick program using our brand-new joysticks.

New Motor and Servo Controller Mounts

September 10, 2011 Practice



The logo for this years's challenge.

Today, we watched a live stream of the challenge being released. We watched live Q&A and the challenge video. We also enjoyed food while watching the broadcast.

After the live session, we went back to work with braistorming ideas and planning the next meeting. We got a few good ideas flowing for working with the objects and containers.

August 27, 2011 Practice

Here is the gear system on
the ball collector.

Today we reconstructed the ball contraption for the robot. Ian and I added gear systems to boost the speed of a wheel to roll the balls. Next week we are considering upgrading some of the gears to chains and adding more wheels to actually shoot the balls into the container.

We finally made a reliable NXT
mound!

On the other hand. I finally made a stable and accessible NXT mount. It also provides easy access to the NXT brick itself. We also moved some components to make room for our new addition of an improved ball collector.


Today was very productive and we are planning on adding on and possibly completing the ball collection device on our next meeting. We also anticipate the release of the actual challenge, on September 10th. I was very impressed by how productive today's meeting was.

August 20th Practice

Today Jaret, Tyler, and I worked on a new challenge which was to collect golf balls and then release them in a determined place. Today though we mainly built the attachment necsisary for the challenge and programmed tests for the different motors. We also are playing with the mount for the NXT which we still can not figure out how we want to mount it. Over all the practice was very productive.

August 13, 2011 Practice



Here is our final robot from today. You
can see my servo attachment on top.

Today we were all here, except for Ian. The goal for today was to get the robot into a position where it could drive around. Jared and Jaret had to leave early, so I added a servo.

The servo operated a channel with a object enclosed. The final program was simple and had the object get dumped off the robot. I have included the code from the dumping program below:




#pragma config(Hubs,  S1, HTMotor,  HTServo,  none,     none)
#pragma config(Motor,  mtr_S1_C1_1,     Wheel_Left,    tmotorNormal, openLoop, reversed)
#pragma config(Motor,  mtr_S1_C1_2,     Wheel_Right,   tmotorNormal, openLoop)
#pragma config(Servo,  srvo_S1_C2_1,    Experimental,         tServoStandard)
//*!!Code automatically generated by 'ROBOTC' configuration wizard               !!*//
task main()
{
  int Universal_Speed = 25;
  servo[Experimental] = 0;
  motor[Wheel_Left] = Universal_Speed;
  motor[Wheel_Right] = Universal_Speed;
  wait1Msec(2000);
  motor[Wheel_Left] = 0;
  motor[Wheel_Right] = 0;
  servo[Experimental] = 90;
  wait1Msec(2000);
  servo[Experimental] = 0;
  wait1Msec(2000);
}

August 6, 2011 Practice

Today we started our meeting with a discussion on our current robots and how to combine the components to make a powerful machine. Ian and I kept our electronic components and Jaret kept the wheel system.

 
Our new robot currently has only wheels. Next week we are adding the electronic components, including the NXT and TETRIX controllers. We had many debates over the robot's design, and now we are on to creating an amazing machine that will work for our practice before the challenge is released.

Our Old Robot Designs

Mine and Ian's robot.

Jaret's robot.

July 30, 2011 Practice

Today we finished our TETRIX creations from last week. Jared was on vacation so Jaret was working alone. After our countless minutes of constructing, we started programming our robots. We started with making the robots go forward, which was all we could do with our starter-robots.

Near the end of the practice, we had a mini sumo challenge Jaret has been dreaming of since day one. The robot that could push the other one out of an area. Jaret won the competition while his robot played a "battle tone". Below is a video from the challange.

July 16, 2011 Practice

Ian and I work on our robotic creation
featuring "brains".

This week we began an exploration in to the TETRIX system. Despite not beginning to program, we learned many part names and building stratagies. We also formed mini-teams to see how our robots compared. The teams were Ian and I, and Jaret and Jared. Jaret was also fixated on making a killer robot instead of complying with FTC rules.

Jared and Jaret worked on a robotic
creation featuring mechanics and
"sumo skills".

The "mini teams" had different stratagies when constructing the robots. Ian and I got a fair foundation with a NXT brick and TETRIX power supply. The other team focused more on "cool looks" and motors. Today's meeting began a new age for J2IT. We will continue the robot construction and programming skills for the new hardware.

July 9, 2011 Practice

Our new robot design with treads.

Today Ian and I worked on two different things. I worked on programming code to complete tasks based on colors detected with our robot's color sensor. The program also used logical sequences to run the code. Ian worked on improving the robot by giving it treads. After Ian left early, I added sensors to the robot and got it working with some of our previous code. I personally learned a lot of new logic statements for the RobotC language. This was my most enjoyable and productive meetings yet. I can not wait to see what the future holds for our RobotC adventures. The full program I made at today's practice is below:




#pragma config(Sensor, S2,     FloorColor,          sensorCOLORFULL)
#pragma config(Motor,  motorB,          RightWheel,    tmotorNormal, PIDControl, encoder)
#pragma config(Motor,  motorC,          LeftWheel,     tmotorNormal, PIDControl, encoder)
//*!!Code automatically generated by 'ROBOTC' configuration wizard               !!*//
void color_read();
void white_task(int forward_speed);
void black_task(int reverse_speed);
int read_output;
task main()
{
  int universal_speed = 25;
  while(1 == 1)
  {
    color_read();
    switch(read_output)
    {
      case 6 :
        white_task(universal_speed);
        break;
      case 1 :
        black_task(universal_speed);
        break;
    }
  }
}
void color_read()
{
  bool value_ready = false;
  while(!value_ready)
  {
    int A = SensorValue[FloorColor];
    int B = SensorValue[FloorColor];
    int C = SensorValue[FloorColor];
    if(A == B && B == C && C == A)
    {
      read_output = C;
      value_ready = true;
    }
    else
    {
      value_ready = false;
    }
  }
}
void white_task(int forward_speed)
{
  motor[RightWheel] = forward_speed;
  motor[LeftWheel] = forward_speed;
}
void black_task(int reverse_speed)
{
  motor[RightWheel] = 0 - reverse_speed;
  motor[LeftWheel] = 0 - reverse_speed;
}