A project of the Robotics Club at Carnegie Mellon University.

Buggy (also called Sweepstakes) is a race held annually since 1920 at Carnegie Mellon. Teams of 5 atheletes (the pushers) push an un-motorized vehicle (a buggy) containing a driver around a 0.84 mile course in a relay format where the vehicle serves as the baton. Roughly half of the course is uphill, during which the pushers run and shove the buggy uphill. During the other - downhill - half, drivers are on their own to navigate tight turns at speeds of up to 35mph.

Borrowed from the CMU Buggy Alumni Association. Visit them to find out more.

In the robotics club we seek to help out robot overlords automate everyone and everything, so we're trying hard to replace a traditional buggy driver with our AI. Alice (the AI) isn't quite ready to take command of Singularity or Transistor, but we still take her out for training during morning practice rolls. Keep on reading to find out more, or just enjoy these team pictures.

Team picture from Raceday 2015.

Trevor pushing Singularity on Hill 4 during early morning rolls.

Singularity	Toothless Transistor
Inherrited from a past incarnation of this project, Singularity has been rolling since 1999. She features a bolted aluminum frame that was originally built around a desktop computer. These days, she features a stylish mount for a Surface on top with the control electronics inside.	Transistor was built for the 2015 season using modern carbon fiber shell technology. She was built to be accessable and maintainable as a platform for the futrue of Robobuggy. Debate within the team on what style she would wear was so fierce we chose to paint her chalkboard black, complete with a new chalking each race.

Looking for more technical docs? Check out the wiki!

+-----------------+
|   Follow Car    |
|        +        |
|  Safety Driver  |
+-----------------+
         ||
         ||
         \/
+------------------+   +-------------------------+
|  Radio Receiver  |   |  Alice (AI on Surface)  |
+------------------+   +-------------------------+
         ||                        /\
         ||                        ||
         \/                        \/
+------------------------------------------------+
|           IO and Safety Controller             |
|                  (Arduino++)                   |
+------------------------------------------------+
                        /\
                        ||
                        \/
+------------------------------------------------+
|               Electromechanical                |
|       (Servo, Solenoids, Pots, Encoders)       |
+------------------------------------------------+
                        /\
                        ||
                        ||
         ____           ||
           \            \/
            \   _____________________
            _\./    \______/      \__\
           < ___o_________________o___\ 
--------------------------------------------------

System block diagram.

Our system architecture keeps a human in the loop all the time, even just to hit the emergency stop button. The human driver can either be sending drive commands (for AI training) or monitoring the AI. The command signals from the AI and human are mixed together (depending on operating mode) in the IO controller. Here we also do last level safety checks like stop on disconnection. The IO controller interfaces directly with the electromechanical systems to make braking, steering, and sensing happen. Find more information in the source directories below.

The software system is seperated into two main directories (sections):

• offline -> where code which is not executed in realtime on the buggy is stored
• real_time -> where code which is being run in realtime on the buggy is stored

This folder also contains:

• Pictures for this readmde file
• configuration files

Special thanks to Microsoft for providing Alice a host interface on a Surface Pro 3!

Think this project is cool? Please support the Robotics Club at CMU!