Arduino Technology System by feq12846

VIEWS: 0 PAGES: 1

Arduino Technology document sample

More Info
									                                                                                                                   System
                             Abstract                                                                                                                                                                               Troubleshooting
An autonomous vehicle is any vehicle that can drive itself from one
                                                                                                                   Lead Car
                                                                                                                                                                              The first several weeks of research were spent troubleshooting the
location to another without the use of human interference. When put in                                                                                                        CMUcam2, the Arduino Microprocessor, and the motorshield then
a convoy, several autonomous vehicles can follow one lead vehicle and                                                                                                         getting them to work independently. Once we accomplished that goal,
mimic its movements. This can have many uses in the private,                                                                                                                  we began to integrate two parts at a time and got them working with
commercial, and government sectors. By using a CMUcam2, an                                                                                                                    each other. Once that was done, we fully integrated all three major parts
Arduino Microprocessor, a Motorshield, and three Remote Controlled                                                                                                            and attempted to get that working. The first major steps we took were
(RC) cars, we were successfully able to create a prototype autonomous                                                                                                         reading over many manuals in relation to the separate parts and
convoy based on light detection technology. One of the three RC cars                                                                                                          previous year’s work on similar projects. The next step involved working
remained unchanged. This car would act as the Lead Vehicle – the                                                                                                              with our Arduinos (previously Arduino BTs, or Bluetooth, but since then
vehicle that the autonomous vehicles would follow. The other two would       Follower 1                                                               Follower 2
                                                                                                                                                                              we have upgraded to an Arduino Duemilanove because it was twice as
be interfaced with a CMUcam2, an Arduino Microprocessor, and a                                                                                                                powerful) and learning how to upload basic programs. Afterwards, we
Motorshield. These cars would become the two autonomous follower                                                                                                              began working with our Motor control and integrating them with the
vehicles. The autonomous vehicles worked in several steps. First, the                                                                                                         Arduinos. Once that was successfully completed, we turned to our
Arduino Microprocessor would send a command to the CMUcam2 telling                                                                                                            CMUcam2, which proved to be one of the hardest challenges. We
it to track a certain color. Next, it would send another command asking                                                                                                       began by focusing the camera through its Graphical User Interface and
for information about the color it is tracking. This information would be                                                                                                     sending it commands through a terminal emulator called HyperTerminal
sent back to the Arduino, where it would be processed and used to                                                                                                             - both of these functions were done on a computer. Finally, we began
determine the turning angle and velocity. After the calculations, the                                                                                                         sending it commands from the Arduino instead of a computer. After
Arduino would send command to the servo motors controlling the angle                                                                                                          much work, all of these tasks were accomplished and integration
of the front wheels and the Motorshield controlling the rear wheels. The                                                                                                      between all three component was successful and programming could
Motorshield would read the commands, and vary the voltage going to          The convoy is made up of three main parts: the lead car, the first follower, and
                                                                            the second follower. The lead car is a normal RC car with relatively few                          begin.
the DC motor controlling the rear wheels, and thus control the speed of                                                                                                                                                      Programming
the vehicle.                                                                changes to it. This is the car that the autonomous cars will be following. On
                                                                            the back of the lead car, a red ping pong ball with an LED light inside is                       Once all the components had been integrated together, programming
                                                                            attached. The two follower vehicles, the autonomous vehicles, will track and                     could begin. The program had to send a command to the camera telling
                                                                            follow this ping pong ball. As the ping pong ball moves within their range of                    it to track a certain color. Next, the program would take in data from the
                                                                            sight, they will make corrections and follow it.                                                 camera, store it, and convert it to a usable form. It would then process
                                 Goals                                                                                                                                       the data and send it out to the motors and the Motor controller. Below is
                                                                                  CMUcam2                           Arduino                     Motorshield                  a section of the code.
    Develop a working convoy of autonomous vehicles using light
                                                                                                                                                                             void loop()                                           posold=pos;                     ///// BACKWARD /////
    detection technology.                                                                                                                                                    {                                                     deltaold=delta;                     else if (dx<-0.2)
                                                                                                                                                                               camera.print("TC 100 180 10 50 0 23 \r");           dxold=dx;                           {
    Look into other forms of autonomous tracking including GPS and                                                                                                             delay(time);                                        dyold=dy;                             posdiff=pos-90;
    accelerometers.                                                                                                                                                           test();                                              ///// VELOCITY /////
                                                                                                                                                                                                                                                                         posback=90-posdiff;
                                                                                                                                                                                                                                                                         steering.write(posback);
                                                                                                                                                                              ack();                                                                                     delay(10);
                                                                                                                                                                              data();                                              V=sqrt(pow(Vx,2)+pow(Vy,2));
                                                                                                                                                                              convert();                                                                                       output=(int)(8*dx);
                                                                                                                                                                                                                                   ///// FORWARD /////
                                                                                                                                                                              if (x1>0)                                            if (dx>0.2)                                 if (output>=200)
                                                                                                                                                                              {                                                    {                                           {
                                                                                                                                                                                                                                     steering.write(pos);                        motor.setSpeed(200);
                                                                                                                                                                               ///// STEERING /////                                  delay(10);                                  delay(10);
                                                                                                                                                                                                                                                                               }
                                                                            The two follower vehicles are nearly identical; the only difference between                        hi=(float) y2-y1;                                       output=(int)(12*dx);                    else if(output<200)
                                                                                                                                                                               wi=(float) x2-x1;                                                                               {
                                                                            them is that the first follower vehicle has its own red ping pong ball with an                     D=ho*hs/(2.0*hi*tanthetah);                             if (output>=200)                          motor.setSpeed(output);
                                                                            LED which the second follower will track. There are three main parts to the                        dx=D-Deq;
                                                                                                                                                                               dxchange=dxold-dx;
                                                                                                                                                                                                                                       {
                                                                                                                                                                                                                                         motor.setSpeed(200);                  }
                                                                                                                                                                                                                                                                                 delay(10);

                                                                            follower vehicles: the CMUcam2, the Arduino Microprocessor, and the                                Vx=dxchange/(time/1000);                                  delay(10);                            motor.run(BACKWARD);
                                                                                                                                                                                                                                       }                                   }
                                                                            Motorshield. The CMUcam2 is a camera attached to the front of the vehicles                         xi=((((float) x2-x1)/2)+(float)x1)-(ws/2)+xcalib;       else if(output<200)
                                                                                                                                                                               xo=(2*D*tanthetaw*xi)/ws;                               {                                   ///// EQUILIBRIUM DISTANCE /////
                                                                            which will track and follow the red ping pong ball based on its color. The                         dy=xo;                                                    motor.setSpeed(output);           if (dx>=-0.2 && dx<=0.2)
                                                                            camera will send information about the location of the ball and its pixel count to                 dychange=dyold-dy;                                        delay(10);                        {
                                                                                                                                                                               Vy=dychange/(time/1000);                                }                                     motor.run(RELEASE);
                                                                            the Arduino Microprocessor. The location is used to calculate the turning                                                                                  motor.run(FORWARD);                 }
                                                                                                                                                                               alpha=atan((2*tanthetaw*xi)/ws);                    }                                   }
                                                                            angle and the pixel count is used to calculate the distance between the cars.
Sponsors:                                                                                                                                                                      alphadeg=(alpha/3.1416)*180;
                                                                            The Arduino will process the information, and send commands to the servo                           delta=(int)alphadeg;                                                                Serial.println(alphadeg);
National Aeronautics and Space Administration (NASA)                        motor controlling the front wheels and the Motorshield. The Motorshield takes
                                                                                                                                                                               deltachange=2*(deltaold-delta);
                                                                                                                                                                               pos=posold+deltachange;
                                                                                                                                                                                                                                                                   Serial.println(dx);

NASA Goddard Space Flight Center (GSFC)                                        the commands from the Arduino and varies the voltage to the DC motors
                                                                                                                                                                                                                                                                   }

NASA Goddard Institute for Space Studies (GISS)                                    controlling the rear wheels, thus controlling the speed.
NASA New York Research Initiative (NYCRI)                                                                                                                                                                                      Future Goals
Rutgers University (RU)
                                                                                                                References
                                                                                                                                                                                     Continue refining autonomous tracking based on light detection
Contributors:                                                               Chukrallah, Bashir, David Laslo, Michael Ma, Sean Murphy, and Stefan Novak. Autonomous Vehicle
                                                                                                                                                                                     technology.
                                                                              Control Systems. Rutgers University, 1 May 2006. Web.
Dr. Haim Baruh, Ph. D., P.I.                                                Gartzman, Steve, Marifae Tibay, Thien Win, Steve Agudelo, Christian Cuentas, and Adekola                 Further research other forms of autonomous tracking including GPS
Alexey Titovich, Graduate Student                                             Adesina. A Convoy of Autonomous Vehicles. Rutgers University, 24 Apr. 2009. Web.                       and accelerometers.
                                                                            Henlich, Jonathan D. "Mobile Robot Navigation." Information Systems Engineering (1997): 1-29.            Leave a working blueprint for future research.
Kelvin Quarcoo, High School Teacher                                           Print.
David Kelly, High School Student                                            Rowe, Anthony, Charles Rosenberg, and Illah Nourbakhsh. CMUcam2 Vision Sensor: User Guide.
                                                                              2003. Print.

								
To top