1. Introduction to Team 294 Programming Concepts
Ken Sterk
7/29/2007
11/12/2018

2. Goals and Objective
To highlight the major software related physical components and programming elements used in a FRC robot
To establish a basic understanding of the base FRC code
To understand the primary functions and algorithms used by team 294
To develop familiarity with the software compilation process and the downloading process
11/12/2018

3. Software Elements How do human commands actually get to robot?
Push joystick/Click button
???
Wheels move, Arm scores.
We win!!!!
11/12/2018

4. Software Elements cont.
Well not quite. Lets expand upon “???”
There are several major items between Pushing the joystick and getting the robot to move
The OI (operators interface)
The FRC robot controller
The Motor controllers and relays and sensors
Victors
Spikes
Encoders, potentiometers, etc
11/12/2018

5. Software Elements cont.
The Software interacts with all of these elements. Thus you can look at the robot sort of like this..
Spike
Victor
Robot Controller
Motors/pneumatics
Operators
Interface
Radio
Sensor
The Robot
11/12/2018

6. Software Elements cont.
So now human commands get to the robot through the following path
Push joystick/Click button
Signals sent from OI to robot controller via radio
Robot controller
??? (oh noes not again…)
Victors and spikes get signals and send power to motors and pneumatics
Wheels move… Arm scores…
We win!!!!
11/12/2018

7. Robot Controller So what does the robot controller do?
Essentially it’s the brain of the entire robot.
The robot controller is simply a small microprocessor.
Using the inputs from it OI and readings from the sensors the robot controller will determine the commands to send the Victors and spikes based upon the algorithms and logic we have written.
It has multiple ports for communication and power
11/12/2018

8. Reset + Program buttons
Robot Controller
Main Power
Programming Port
Tether port
Radio Port
Backup Battery
PWM outputs
Analog inputs
Digital I/O
Reset + Program buttons
11/12/2018

9. Operators Interface
That is the OI is an integrated piece of hardware that interprets signals received from analog/digital inputs such as Joysticks, buttons, toggle switches.
It has the ability to send data and receive data
Receive data such as our HUD (heads up display) or error data.
Sends joystick data, switch values, etc.
11/12/2018

10. Operators Interface cont.
Competition
Port
Tether
Port
Radio
Port
Dashboard
viewer port
Port 3
Port 1
Port 2
Port 4
LED Display
toggle
Team #
dipswitch
Reset
11/12/2018

11. Victor Spike
The Victor 884 is a speed controller used by the FRC robot controller board to command the motors to run
It gets a PWM command from the robot controller
Through its internal circuitry it generates a current to provide the motors based upon the input PWM value
The Spike is essentially a small switch that allows current to either pass in one direction or another.
It can be used to drive small motors in forward, reverse, or stop (brake). 
Or more commonly it is used to drive the solenoids we use in out pneumatic system to open or close valves.
11/12/2018

12. Sensors
There are several sensor types that have been used by team 294 in the past few years.
Briefly we have used:
Potentiometers
Simply a variable resistor that outputs a different voltage based upon what angular position it is at.
Used to measure our angular position based upon a reference position.
Encoders
Used to measure angular rotation, or angular rotational velocity.
Either magnetic or optical in construction, outputs a simple set of pulses per revolution.
Rate Gyro
Measures the angular rotational rate.
Useful for determining overall robot rotational rate
Camera
Obviously it’s a camera. It outputs relative angles of the object that its looking at based upon its calibrated color its looking for
11/12/2018

13. Sensors cont.
Potentiometers
Encoder
CMU camera
11/12/2018

14. Getting Started with Code
You need a computer….duh
You will need a serial port or a USB to serial converter
Download or install all the necessary programs
MicroChip MPLAB:
This is the default FIRST C programming environment. This is where all of our code will be written. We can open projects and modify the code here. There are several different types of compilers and environments.
C-18
This is the compiler to translate the written code into a language that is recognizable to the embedded microchip in the robot controller. The compiler is specifically tailored to compile the code to a specific set of microchips.
IFI-Loader
This is the default software used to program the actual robot. It uses the serial connection between your PC and the robot controller.
The FRC Default source code
The “source” is essentially a fancy word for all the logic that we are going to edit and the put on the robot
11/12/2018

15. Getting Started with Code
C Code Hierarchy
.c -Source Files
.h -Header Files
.lib -Library Files
.lkr -Linker Scripts
We will edit the .h and .c files
Compile and download to the RC
11/12/2018

16. Working with Code
We are primarily concerned with modifying only the .c and .h files in the code.
More specifically we are going to be modifying the user_routines.c and user_routines.h file.
Here we have code that enables us to read inputs from the OI
We can sample the inputs from the sensors
We can the utilize this information and run our custom functions (PID) to make the robot do what we want to do.
To understand how this all works together we will take a look at how all the code is put together
11/12/2018

17. Working with Code What is this .c and .h file?
The .c file is considered the source file.
This file is where the actual math is done. It is where you will put all your functions.
Eg. Motor1= (255-JoystickInput)*scale;
The .h file is called the header file
The header file is where we enumerate (define) all the variables that we are going to be needing for the functions called in the .c file
It should have the same name as the .c file
11/12/2018

18. Working with code: Main.c
Everything starts within the top function called main.c
This function simply calls all the necessary functions needed to run the robot.
It first will initialize all the variables that you have defined
It will the process all the inputs
It will run autonomous code if needed
And finally it will execute all of your written algorithms and write the data to the output of the controller.
11/12/2018

19. Working with Default Code
11/12/2018

20. User_Initialization
This is where we initialize all of the variables to their starting values
Initialize PWM values to send to victors as neutral (127). More on this later
Initialize the digital inputs and outputs
Initialize the input and output ports for use in the code
11/12/2018

21. Working with Default Code
11/12/2018

22. Process_Data_From_masterUP
The name sounds complicated but in reality it calls a set of functions used to read in the info from the camera.
It also is used to process any other data from any other sensors that need to be read
But most importantly it calls the default_routine.
And finally it will take all the data written by the default routine and put the data on the output ports of the robot controller.
11/12/2018

23. Default_routine
The default routine is the basic code that is used to control the robot.
This is the location where team 294 does the majority of the changes to the code.
The default code is preloaded onto the Robot Controller which provides a way to simply build a robot and drive it around without worrying too much about programming
11/12/2018

24. Default_routine
Since the code is so long only snippets of the code will be shown.
Essentially it does two things
Reads the OI values from the joysticks and assigns the correct PWM to each wheel
Maps button presses on the joystick to the relay outputs on the robot controller
11/12/2018

25. Working with Default Code
11/12/2018

26. Autonomous code
This is the special code position where we will put out autonomous functions.
Only used when autonomous time is valid.
The default autonomous code does nothing
This runs in the user_routines_fast file
11/12/2018

27. Working with Default Code
11/12/2018

28. Process_Data_From_Local_IO
Another really long name that does not do anything too complicated
All it does is process data every program loop
So if you have something that needs to be executed every single program loop this is where you will put it
The only thing team 294 has running every loop is the autonomous code
We have also experimented in the past with using interrupts for reading in inputs from other sensors
11/12/2018

29. Changes to the Default Code
Team 294 does make some changes to the default code
These changes enable us to do much more complicated things.
We have code to drive the arm linkages by using a PID algorithm.
Operate the gripper to effectively grab game pieces and score points
Autonomous code to score during the autonomous periods
In addition we have cleaned up some of the initializations to make the code more legible and intuitive
11/12/2018

30. 294 Code Changes
All these changes exist with in the files we just covered before.
The files we have changed are
User_routines
We wrote our own default_routine. Now called control_routine
User_routines_fast
We have added our own autonomous code
11/12/2018

31. Control_routine This is the code used for the 2007 robot
For the control routine to work we needed to first add initialization to the arm motors. Hence we have added this line to the User_initialization function
11/12/2018

32. Control_routine cont. Now onto the bulk of what we have done
What we are attempting to do is take in commands from the OI and make the robot do what we want to do
First: Drive all 6 motors based upon the commands sent by the joystick
Second: Move the arm to a predefined position that we want to go.
E.g. Pick up off ground, Score, descore. Etc
Operate the pneumatics to open and close the gripper to pick up the game piece
So lets take a look at that your teammates wrote
11/12/2018

33. Control_routines cont.
First we define all the internal variables to the function.
Eg. The grabber state, the arm command, etc
Next read in the actual arm positions from the sensors (potentiometers)
Then set the arm pwms to 127
A pwm of 127 is considered to be zero motion
The pwm ranges from 0-255
0 being full reverse and 255 full forward.
11/12/2018

34. Control_routines cont.
Next we have modified the drive code to drive all 6 motors we have on the robot.
If you notice that the names are different than calling it pwm01, pwm02
The reason for this is to make it simple to read the code.
The actual mapping of the “LEFT_DRIVE_CIMS” is located in the header file!
We have also included the ability to let the operated reduce the top speed of the robot for a fine control of the driving
11/12/2018

35. Control_routines cont.
Next is the arm commands
In 2007 we had two ways to control the arm
First we could use a “fine tune” using the co-drivers joystick
Or we could use the preset positions for pickup, score low, score high etc.
These used the toggle switches on the on the control board
11/12/2018

36. Control_routine cont.
Fine control. Takes the input from the joystick and issues a new command to the arm (either shoulder or elbow) in small increments
This calls the PID function to be reviewed later
Again notice the variables names to be intuitive and easy to understand
Also comments are really useful to separate out the code
11/12/2018

37. Control_routine cont. Using preset positions.
Only one shown for brevity
Sets the command to a predefined position
Positions set via calibration before the match
11/12/2018

38. Control_routine cont.
This is the code to effectively run the gripper. It will open and close based upon the drivers commands
11/12/2018

39. control_routine
Finally the arm command has been set, the gripper is either set to open and close
But now we need to send the arm commands to the motors.
We do this through a function called PID
What PID is a very effective method to write the PWM commands to the motors.
It uses the error between the arms current location and commanded position to determine how fast it should go
There is a ton of theory here that we can go over another time
The PWM are then written by the PID function and sent to the arm motors
That then finishes off the control_routine!
11/12/2018

40. Autonomous code
In the user_routine_fast file simply add in the code you want to execute under the autonomous
In 2007, we never got autonomous code fully tested due to a variety of other problems
In 2006 we had a fairly effective autonomous code that could select between several options to score
In 2005 we had a very simple set of code to score a couple points consistently
11/12/2018

41. Wrapping it up… So we have covered:
Some of the basic elements that are used as interfaces between our code and the actual robot
The tools necessary to build and compile code onto the robot
A quick (hopefully) overview of what the default code looks like and how it runs
Finally, the changes made to the default code by team 294
11/12/2018