December 31st meeting

Today I made refined our joystick control system. I made the tank drive a lot better by adding a refined equation (JoyValue / 127 * 100 = Motor Value) that scales the joystick value of -127 to 127 into -100 to 100. I used the D-pad to make the elbow work a lot better, so i can refine it degree by degree. Tyler worked on the auto program to make it work better. It can now get the bowling ball but he is still working on getting the bowling captured.

12/19/11 Meeting

At our meeting we did many things. I did refined the joystick program to make expectational output. The equation is

MotorOutout = ( joystickValue ^ 2 / max joystickValue ^ 2)

Scrimmage Results

Congratulations Team on a great scrimmage.  8 FTC teams participated and all were high school except J2IT.  We scored 2nd place overall and had the single highest scoring game of the day.  We learned some great strategy and also some got some great ideas from the other teams to help finish our robot for the January competition. Thanks Hudson for hosting this great event.

Pre-Scrimage Meeting

Today our team was preparing for the scrimage at Hudson High School. I feel that we are well prepared even though our scisor lift has to be operated by the arm and not an independant motor. Today Jaret and Tyler worked on the programs revising and preparing them for the compotition. Ian and I both worked on tightening screws and packing materials for the compotion. I think that we will do well against the other high school teams, but I do not think we will come in forst for this scrimage compotion.

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 28, 2011 Meeting

Today Jaret worked on the programming for the arm.He made good progress with that. Jared worked on fixing the kinks on the robot. Tyler started programming for the autonomous mode. He is making 2 programs, one for if we are the red team and one for if we are on the blue team. Today ian worked with the lift and he tried to make a triggering system. He is still trying to figure it out.

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

Robot Photos

The "Guts"

Our new 4.2 wheel drive.

Ian D. working on mounting the scissor lift.

Jared R. fixing the transmission's gears.

Tyler T. mounting the Infrared Sensor.

An early test of the articulated arm.

The arm looks cool even if it didn't work.

The new scissor lift.

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.

FTC Competition Video

Check out this video of one of the first FTC competitions this year. 

http://youtu.be/WAamee1D8SU

November 11, 2011 Meeting

Today Tyler started working on the autonomous program for the competion. He was working with the infared sensor to align the robot in the playing field no matter what color we are. Today Jared finished attaching the plastic wheel guards that aid in protecting the wheels.He spent the remaining time preping the robot for attaching the claw mechinism. Ian continued working on the scissor lift. He made a track for the bottom to follow and added a support beam through the center. Jaret, unfortunately, was not present at today's meeting.

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.

Meeting Review 10/29/11

Today was a very productive meeting. I (Jared) worked on the hand again and might have finally finished on the comlpete desighn including the newest desighn change the magnetic sensor.Tyler finally completed the stall program and is now experimenting with using the encoders. Jaret and Ian worked on our future plow and fixed other minor flaws in our robot. Jaret and Tyler also tried programing our arm but they decided to do something else instead. Today we had a very productive meeting and I think that we are now steadying to a fairly good pace.

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 15th meating

Today we did some things. Jared worked on the claw and it seemed he made a little bit of progress. I worked on the joystick and got it to work better. And Tyler worked on an inferred program hat seems to work really well and is very good.

October 8, 2011 Practice

Today, Jaret and I dove into the new sensors, magnetic and infared. We got both sensors working in a basic manner, and I am waiting to test a more advanced IR beacon tracker. A video with the concept is on the left side. We also mounted a new "device" to the robot.

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.

October 1, 2011 Practice

What We Did:

Today we added a support system to our robotic arm. We set up the final wiring and gave the arm some movement.

What We Learned:

Our team had a scary experience of our arm's motor almost burning out.
The odor of smoke was emmiting from our motor.Next time, we need to be more careful with tge arm's power and the control of "new" devices.

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.

August 26th Meating

Today we worked on a lot of stuff. Jared worked on making an arm. Tyler worked on the automounus code and I drove the robot with the joystick program. Thats pretty much all we did on this meating!

Mark your calendars...

J2IT is now offically registered to compete in the FTC OH Regional Qualifying Tournament on January 13-14, 2012

   Robot/Software Inspections Friday, January 13, 6:00 – 8:00 pm
   Tournament Saturday, January 14, 7:30 am

Location

Cuyahoga Community College
Eastern Campus
4250 Richmond Road
Highland Hills, OH 44122

FTC-OH Qualifying Tournament

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.

june 14th meeting

Jaret and I were the only one at the meeting i worked on a acceleration sensor controller its pretty cool. Jaret was working on a random number generator and a X-box remote controller.

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;
}

June 28, 2011 Practice

Today was a small meeting with only Jared and I, due to Ian and Jaret both taking family vacations. Together, we accomplished creating a claw and giving the robot a better rear "wheel". We also discussed ideas for our claw and robot. In the programming department, I made a program that starts in a box and travels to the other end than turns around. To help with motors, I created a global variable for motor offset. In my opinion, this was one of our most successful meetings yet.

Here is a small sample of code from the program that turns at line (I did not define the functions):
task main()
{
  int universal_speed = 50;
  int light_threshold = 45;
  straight(universal_speed, false);
  wait1Msec(1250);
  straight(universal_speed, true);
  while(1 == 1)
  {
    while(SensorValue[Light_R] >= light_threshold)
    {
      straight(universal_speed, false);
    }
    straight(universal_speed, true);
    turn_r(universal_speed, light_threshold);
  }
}

June 21 Meeting

Today we practiced using the joystick to control the robot for the first time. We also started to explore the gyroscopic sensor and programing with it. Tyler also tried to follow a course by detecting lines. Overall a very good practice.
:)

New way to practice your RobotC at home

Thanks to Carnegie Mellon and The Computer Science Social Network (cs2n.org) we've got a great new software that you can download for free at home. I've tested some of our programs in the simulator and its pretty realistic.   It will let you use the RobotC at home and simulate the Lego robot on your computer.  You can download the software HERE.

http://dl.dropbox.com/u/25222170/RVW_NXT_TechAlpha.exe

For more information on the H99 NXT Simulator for RobotC try these links:

http://www.cs2n.org/h99

http://www.cs2n.org/h99/learn_lego


Try it out and let me know if what you think.

Next Practice: Tuesday June 14th at 4:00 PM,

Terry

Practice Tuesday June 7th 2011

Today we did things.... THINGS, not just any little "things". Big, no BIG things, we made a fast line following program that could line follow with 2 light sensors. It wass very fast and further reinforced my skills. We learned about gyro and acceleratorion sensors. We had to also attached a second light sensor and attached a gyro and acc. sensors. We sadly took down our sound and Ultra-Sonic sensor. :''(

Peace OUT

Meeting Schedule for June 2011

Just a quick note about team practice next week.  There is a conflict with scouts and our scheduled FTC meeting next Saturday.  

After discussion with parents, it sounds like Tuesdays (4pm-6pm) will be a good backup day for weeks when Saturday won’t work.  Through the summer, if there is a conflict with 2 or more of the team, just let me know and we will plan to meet the Tuesday before our regularly scheduled meeting.

• Practice: Tue June7th
• No Practice Saturday June 11th (Scouts)
• Practice: Tue June 14th
  
• No Practice Saturday June 18th (Tyler/Ian out of town)
• Resume Regular Practice: Saturday June 25th

 Please let me know if you have any questions or concerns.

June 4, 2011 Practice



Ian, Tyler, Jaret discussing a flow chart.
Flowcharting is a necessary skill in
the FTC.



In this practice session, we worked on tasks like counting a total number of lines and line following with directional commands. Ian and Jaret worked on additional challenges and Jared was getting caught up after his baseball games. He was working on line following. I accomplished the main goals with support from the team. We all fixed the issues from practice two and quickly edited the program to get everything working. We also improved our note-taking skills by learning flowcharting. Our meeting would be called a good use of time by all team members and coaches. We are strongly looking forward to really getting to work with TETRIX sensors and servos.


Jared debugging code.



Flowchart

I choose to use a "System" flowchart. You bassically use a diffrent shape for each command. This allows for easier reading and for good uniformed organization. They can be used for different purposes ie. solving a problem or designing a procces. In some cases, such as me, it may be easier to understand a flowchart than a program.

www.wikipedia.com/flowcharts

May 28 practice lessons learned?

I apologize guys, I should have checked the robot after the training meeting last Saturday. I didn't think anyone used it so I didn't worry about it.

Were you able to get the robot to work at all? What kind of troubleshooting did you try? What do we do if this happens on game-day? Should we invest in 2 robots if the team raises enough money? What do you think caused this problem? Do you think this kind of thing happens to professional engineers? If so, how do you think they handle it?

Again I'm sorry it didn't go as planned, but I'm glad you worked together to try and fix the problem. As much as I hate these kinds of problems - they can and do happen in all kinds of jobs. They also can teach us alot about our selves and our team. If you learned something about yourself, share it.

Thanks again to Mr. Ruehr for filling in while I was geeking-out in Baltimore. See you Saturday June 4th.

- Terry

Homework

I chose to use a program flowchart. I chose this kind of flowchart because a program flowchart demonstrates how a program works within a system. These flowcharts show any and all user-interaction pathways by using boxes and arrows. Program charts can be large and complex. However, they are useful for mapping an entire program. The example I made would have the robot turn one way until it saw a dark line then it would stop.  

Second Team Meeting - May 28, 2011

At a team meeting with only Jared and I, we experienced a problem with the robot. Our goal was to recover the robot, but we failed. Due to this dismaying discovery, we just programmed and achieved all of the line following program and got a decent start with the "pill push" line task.

may 28th practice

this practice we did not get much acomplished because we were trying to figure out what was wrong with the robot because it would not start up and kept making a cliking sound we needed some help for this practice.

my home work

I will present the rest of my homework at our next meeting it's not really a flow chart but it is similar enough

superjor's goals

I want to take F.l.l. one step further and get used to real programing code another one of my goals this year is to have fun which is the whole point of this competition

Tyler's Homework, May 20

The type of flowchart I researched was a system flowchart. This would be effective with our program mapping due to listing inputs and outputs with symbols, as well as data flow. My informtation source is eHow. Click here to veiw the specific page for the information.

First Team Meeting - May 14th 2011

Jared R., Tyler T., Jaret S. Discuss Team Goals

Jaret S. working with RobotC

Tyler T. working with sensors in RobotC

Welcome to J2IT's Team blog!

Stay tuned for more info!