RobotC – A Tutorial II. Learning from yesterday REVISION The IDE Functions and usage of various...
-
date post
19-Dec-2015 -
Category
Documents
-
view
215 -
download
1
Transcript of RobotC – A Tutorial II. Learning from yesterday REVISION The IDE Functions and usage of various...
Learning from yesterdayR
EV
ISIO
N The IDE Functions and usage of various panels
Top Menubar Side Functions panel Code Window Error Window
Compiling/Downloading the code Running the program
C Programming Syntax Capitalization Whitespaces Comments Variables Boolean Algebra
Learning from yesterdayR
EV
ISIO
N Control Structures Tasks Functions If-Else/Switch While/For
Today we are going to look at specific commands andoptions available in RobotC for controlling the NXT
SE
CT
ION
3
Reserved WordsMotorsTimersLCD Display
Sensor Configuration
Debugger UsageTasksFunctionsIf-Else/SwitchWhile/For
Section Overview
OverviewR
OB
OT
C F
EA
TU
RE
S
RobotC has a variety of commands, interfaces and options which deal specifically with robots. Some of these are
Reserved words like motor, timers (keywords) Sensor interfaces Live debugger
KeywordsR
OB
OT
C F
EA
TU
RE
S
RobotC has a variety of keywords which are used for issuing specific commands to the NXT controller
As it is not possible to cover all the commands in detail here, only the main ones will be discussed.
Explore the rest of the options by using the help available within the programming environment or online version (as explained earlier)
MotorsR
OB
OT
C F
EA
TU
RE
S
Motor control – Turn on/off at a certain power level
General Syntaxmotor[output] = power;
ParametersOutput – Determine the motor to affect. This can be motorA, motorB, motorCThis command just gives power to the 3 output ports A, B, C in a certain fashion. This can also be fed to a circuit to control other devices
Power – Determines the power at which the motor is to be run. This can take any integer value from -100 (full reverse) to 100 (full forward)
Examplesmotor[motorA] = 60; //Run motor A at 60% powermotor[motorB] = -50; //Run motor B in reverse at 50%motor[motorC] = 100; //Run motor C at full power forward
Motors – 5 minute activityR
OB
OT
C F
EA
TU
RE
S
Using the simple motor command, try to write a program that spins the RoboCar as fast as possible
How fast does it rotate? (RPM)
Motors – 5 minute activityR
OB
OT
C F
EA
TU
RE
S
How did you do? Here is one solution:
task main(){ motor[motorA] = 100; motor[motorB] = -100; while(true)
;}
…where you turn both motors at full power, opposite direction.
At this point, just take a moment to think of all the other factors which may have affected your spin rate (battery power, weight imbalance, friction, etc)
Robust code accounts for as many uncertainties as possible
Timers – Wait TimersR
OB
OT
C F
EA
TU
RE
S
The wait commands allow you to insert delays into your program. Its like starting a stop watch and pause the execution of your program.
The pause in execution means that the next command will not be executed till after the timer expires. However, the actions due to the commands already issued will continue.
There are two commands related to thiswait1Msec(wait_time);wait10Msec(wait_time);
Parameterswait_time – Refers to the time for which the program pauses before proceeding to the next step. The units are either milliseconds (1/1000 of sec) or 10s of milliseconds (1/100 of sec)
Timers – ExamplesR
OB
OT
C F
EA
TU
RE
SThe following examples uses the wait function to allow the motors to operate for 1 second at a time.
Motors – 5 minute activityR
OB
OT
C F
EA
TU
RE
S
Using the encoder command, try to write a program that rolls the car forward a distance of approximately 2 feet
Motors – 5 minute activityR
OB
OT
C F
EA
TU
RE
S
How did you do? Does your code look something like this?
task main(){ motor[motorA] = 100; motor[motorB] = -100; wait1Msec(2000); // however long it takes to go 2ft}
LCD DisplayR
OB
OT
C F
EA
TU
RE
S
The LCD display on the NXT is a 6 line display that can be controlled via functions in RobotC.
It can support a display of 16 characters per line
The display is an extremely useful resource during the debugging phase, for observing the values of various inputs and outputs.
If left unmodified, the LCD will display the readings of the input sensors and the output power level of the motors.
LCD Display - FunctionsR
OB
OT
C F
EA
TU
RE
S
Two functions that may be useful to access the LCD are
nxtDisplayStringAt(xPos,yPos,text,var1,var2,var3) – print texteraseDisplay() – clear the NXT display
ParametersxPos - Number of pixels away from the left of the display that you want your string to be printed at.
yPos - This integer value is the number of pixels away from the bottom of the display that you want your string to be printed at.
text - The text parameter is what shows up on the screen. This will be a string enclosed in quotes up to 16 characters. You may also display up to 3 variables in this string by adding %d, %f (conversion specifications) up to three times.
var1, var2, var3 - These (optional) parameters define which variables will be displayed to the screen and each must correspond to a separate %d, %f within the text parameter.
Motors - EncoderR
OB
OT
C F
EA
TU
RE
S
Each standard Lego motor has an inbuilt encoder that can be used to measure the amount the motor has turned by, or turn the motor by a specific number of degrees
General Syntax (to obtain the reading)myVar = nMotorEncoder[output]General Syntax (set the turning amount)nMotorEncoderTarget[output] = numCounts
Parametersoutput – Determine the motor to affect.
numCounts – The number of encoder counts that the motor must turn before stopping
myVar – a variable that gets assigned the current value of the encoder
Motors - EncoderR
OB
OT
C F
EA
TU
RE
S
Encoder Example (To turn to desired value by setting)// Set degrees that motor A must turn to 1000nMotorEncoderTarget[motorA] = 1000;
// Turn on Motor A. It will automatically stop // after turning for the desired amountmotor[motorA] = 75;
Encoder Example (To turn to desired value by observation)// Turn on motorA until it has turned 1000 degreesmotor[motorA] = 75;while(nMotorEncoder[motorA] <= 1000) ;motor[motorA] = 0; // requires explicit stop
Motors – 10 minute activityR
OB
OT
C F
EA
TU
RE
S
Write a creative programming solution to navigate thefollowing course – without using any sensors. Based on whatyou have already learned
2 ft
2 ft
1 ft
Motors – 10 minute activityR
OB
OT
C F
EA
TU
RE
S
Here are a couple of suggestions
Go straight for a fixed time (calculated by trial and error)Then turn right and go further straight for some more time (again calculated by
trial and error)Then turn left and go straight
OR
Measure the circumference of the wheel to get how much the car will travel in one revolution.
Use this number and the distances mentioned on the track to get the desired number of revolutions before turning
Set the encoder accordingly and GO!
OR
Mix the above 2 methods
Sensor InterfaceR
OB
OT
C F
EA
TU
RE
S
RobotC has an extremely powerful sensor interface which may be used to communicate with Lego and other third party sensors.
Ideally, RobotC sensor interface provides an enormous degree of freedom to the programmer.
It provides several options for configuring the sensor ports to1. Read the raw value – Mainly used for self designed
sensors2. Communicate via the I2C interface – Mainly used by third
party providers3. Work using standard protocols and thresholds with the
standard Lego sensors
Sensor Interface - AccessingR
OB
OT
C F
EA
TU
RE
S
The sensor interface in RobotC may be accessed through the Robot Menu on top of the IDE.
The steps for accessing the sensor menu are as follows
Click on the Robot Button on the topmenubar and select the Motors and Sensors Setup box
Sensor Interface - AccessingR
OB
OT
C F
EA
TU
RE
S
Click on the management tab. This brings up the options to select the kind of sensors that are displayed
Tick the bottom3 boxes. Unless you want to use old RCX Sensors
Sensor Interface - AccessingR
OB
OT
C F
EA
TU
RE
S
A popup will occur as depicted. Choose the A/D sensor tab.A/D stands for Analog to Digital
You can configureup to 4 sensors
Type of sensorsFields for specifying thenames of the sensors
Sensor Interface - AccessingR
OB
OT
C F
EA
TU
RE
S
Give a name to the sensors you intend to use and configure it to a certain type from the drop box
Type of sensorsThis one is being configured as SONAR
names given to the three sensors
Sensor Interface - AccessingR
OB
OT
C F
EA
TU
RE
S
Click on OK. This will create some auto-generated lines of code at the top of the program. This means that the sensors have been configured for use in the program.
Observe,No line numbers
Auto-generated code.
DO NOT EDIT THISGiven sensor names
Sensor Interface - AccessingR
OB
OT
C F
EA
TU
RE
S
After configuration, using the sensor values in the program is a trivial task — two methods of obtaining the sensor values:
myVar = SensorValue(sensor_name) myVar = SensorRaw(sensor_name)
The first method returns the configured sensor value.Second one returns the raw value.
Parameterssensor_name – This denotes the name assigned to the sensor in the configuration step
Both may be used to obtain sensor readings (either raw or calibrated) The choice of method depends upon intended use
Sensor InterfaceR
OB
OT
C F
EA
TU
RE
S
Each sensor after configuration has two types of values
Raw value – This is the raw value that the NXT observes based on the voltage across the input port. Every sensor has a raw value reading.
Varies between 0-1023 (10 bits)
Sensor Value – Obtained after application of thresholds to the raw value based on the configuration.
Range depends on the configuration. More apt as per application
Example: For a sensor configured as a touch sensor
Raw Value 0-512 512-1023
Sensor Value 0 1
State Released Pressed
Sensors – 10 min activityR
OB
OT
C F
EA
TU
RE
S
Configure the sensor on port 1 to be a light sensor.
Write a snippet of code that looks at the sensor reading and displays a “Light!” or “Dark!” message on the NXT screen when the light sensor is over a light or dark surface.
DebuggingR
OB
OT
C F
EA
TU
RE
S
Debugging is one of the most difficult parts of writing code
Fortunately, RobotC has an extremely powerful debugger, much better than other languages for similar functions
Debugger – Not CompilerR
OB
OT
C F
EA
TU
RE
S
Debugging generally refers to solving logical fallacies in the code.
The compiler will give ERROR messages ONLY for syntax errors. You cannot run a code with syntax errors
The compiler does highlight potential logical flaws in the form of WARNINGS and INFO messages. But these MAY or MAY NOT be the source of the logical problems.
It is a good practice to make sure you have fixed all warning and info messages as well.
Debugging - OptionsR
OB
OT
C F
EA
TU
RE
S
Compiling and loading the program on the brick will enable several new debug options which were previously disabled or inactive
Each of these windows is significant for a particular kind of error tracking
The most important ones are
1. Global Variables
2. NXT Devices
3. Task Status
Debugging - ExampleR
OB
OT
C F
EA
TU
RE
S
Consider the example on the next slide for the purpose of debugging
There are intentionally created errors in that program
Lets see if they can be identified using the debugger
DebuggingR
OB
OT
C F
EA
TU
RE
S
This variable is not being updated, so mustn’t be assigned
These variables have identical values assigned, but according to sensors; they should be different
What errors can be identified from here??
More clues …
RO
BO
TC
FE
AT
UR
ES
variable light_sensor is not assigned
variable dist_sensor is getting light_sensor reading
Lets see how accurate we were
Thus we were correctly able to identify all errors
DebuggingR
OB
OT
C F
EA
TU
RE
S
All seem good and in correspondence
PERFECT!!!
Lets see how the debugger looks with the corrected programs
RO
BO
TC
FE
AT
UR
ES
Lets correct the program
Observe the color of these X’s.
Recall from yesterday.
These are simple information messages.
Why do you think they are reported?
The compiler is trying to tell you that though you have declared and assigned these variables, you have not used them anywhere in the program.
So it is trying to save your memory and flag potential errors.
Sometimes, you tend to declare a variable with the intention of using it but end up using the wrong variable with a similar name. This can lead to really unpredictable results.
One of the most difficult logical errors to catch
DebuggingR
OB
OT
C F
EA
TU
RE
S
One of the major sources of problems is disconnection of an input sensor from the port, either due to a loose connection, or inadvertent connection to the wrong port
In this example, the light sensor from port A is connected mistakenly to port C
Observe how the raw value of port A is saturated at 1023 while there is an undesired value on port C
DebuggingR
OB
OT
C F
EA
TU
RE
S
One common problem with many codes is missing timing delays.
Such mistakes cause a lot of confusion and undesirable results
These are difficult to catch by using the debugging techniques discussed
They can be better examined by using the step by step debugger of RobotC
These commands allow step by step execution, hence giving more control for analysis
Debugging - ExampleR
OB
OT
C F
EA
TU
RE
S
Consider a program that moves the car forward till the light sensor reading is above a threshold (i.e. it is bright). If it sees a shadow, or darkness, i.e. the value of the light sensor drops, it backs up for some distance and then tries again
This program has the error that as soon as the car sees the black line or black shadow, it stops rather than going back.
Debugging - ExampleR
OB
OT
C F
EA
TU
RE
S
Lets try to use the debugger stepping to solve the problem.
We can see that if we select continuous update of the values, then the green line moves extremely fast and we are unable to understand anything.
Debugging - ExampleR
OB
OT
C F
EA
TU
RE
S
The way around this is to suspend the program by clicking the suspend button.
This pauses the execution of the program leaving all the variables and sensors intact
The sensor readings and motor tachometer readings keep getting updated even in the suspend mode
Then click the step into button.
This will cause the green line to be replaced by a yellow one which will stay on a specific statement
You are now using the stepping mode of the debugger
Debugging - ExampleR
OB
OT
C F
EA
TU
RE
S
Each successive pressing of the Step Into button will advance the program step by step
Debugging - ExampleR
OB
OT
C F
EA
TU
RE
S
Going through a few iterations in a stepwise manner, we can see that reason for the car to not back up is the lack of delay while running in the reverse direction
This can be rectified by adding a simple delay command after issuing the commands for the car to go backward
Common ErrorsR
OB
OT
C F
EA
TU
RE
S
What is the error in the code below?
There is no break statement. So all statements after case 2 will execute!
So even though the motors are supposed to run at 20% power only, they will instantly cycle through 20%, 30% and finally 100%. So you will always see motors turned on at full power
Common ErrorsR
OB
OT
C F
EA
TU
RE
S
What is the error in the code below?
In the if condition, the variable has to be checked to be equal to 30. So == should be used (binary operator)
In the current form, the variable will be assigned the value 30 inside the if. This overall operation returns 30, which in Boolean terms is true. So motors will always run at 20% power
SummaryS
EC
TIO
N S
UM
MA
RY
In the final section, you learned
1. RobotC specific keywords and usage
2. Sensor configuration and usage
3. Use of the debugger and various methods of debugging
This completes the basic tutorial on RobotC.
You should now be familiar enough with the basic concepts to build sufficiently complex systems
HelpS
EC
TIO
N S
UM
MA
RY
In case you need help
1. Have a look at http://www.robotc.net/teachingmindstorms/
2. Use the in-built help in the IDE
3. Ask Google
4. If you are still stuck, ask your TF/TA!!!
…and like mentioned initially, always remember - your design and needs should guide the language and not the other way around!!
ExerciseE
XE
RC
ISE Write a program make the RoboCar go around in circles of a
certain fixed radius (say 1 ft)
ExerciseE
XE
RC
ISE Write a program make the RoboCar go straight for 2 feet, turn
around, return to the start position, and repeat once more.
ExerciseS
EC
TIO
N S
UM
MA
RY
Write a program that will move the RoboCar forward until it sees a second black line, then turn around three times and stop.
Motors - SynchronizationR
OB
OT
C F
EA
TU
RE
S
Synchronization – Used to ensure movement of both motors in synchronization (either same speed or different)
When the motors are not perfectly aligned, the program makes adjustments to their power to bring them together again.
General Syntax (3 steps)nSyncedMotors = syncPair;nSyncedTurnRatio = ratio;motor[output] = power;
ParameterssyncPair – Denotes the pair of motors to synchronize. This can take values synchAB, synchAC, synchCB, synchCA and synchBA, synchNone. The first of these denotes the master and the second one the slave
ratio – A value between +100 to -100 denotes the ratio of the speeds between the master and the slave. Negative denotes the opposite direction
Motors - SynchronizationR
OB
OT
C F
EA
TU
RE
S
Synchronization Example
// Synchronize motor A and B with A being the master and B being the slavenSyncedMotors = synchAB;
// Specify the turn ratio. nSyncedTurnRatio = 50;// This means that the power of the slave motor (B here) must be 50% of the power to A
// Specify the power of the master motor (motor A) motor[motorA] = 75;
Motors - OtherR
OB
OT
C F
EA
TU
RE
S
There are a variety of other degrees of control which can be implemented in motors. May not be useful in the immediate context but good to know. Use the help menu to get elaborated details
bFloatDuringInactiveMotorPWM - Indicates whether to float the motor inputs or apply immediate brakes when attempting to stop
nMotorRunState[] - Contains the state (idle, ramping up or down, steady state, holding encoder position while stopped) of a motor.
bMotorReflected[] - Boolean flag to indicate whether motor direction should be ‘flipped’ or ‘reflected’ from the normal.
nMotorPIDSpeedCtrl - Turn on the PID controller for that motor.
Motors – PID ControllerR
OB
OT
C F
EA
TU
RE
S
Turn on the PID controller for that motor. The PID control adjusts the actual amount of power sent to a motor to match the desired value, specified in the program.
General SyntaxnMotorPIDSpeedCtrl[output] = optionValue;
ParametersOutput – Determine the motor to affect.
optionValue – Enable or disable PID control for the given motor. This can take the value mtrNoReg to disable the PID or mtrSpeedReg to enable to PID
ExamplesnMotorPIDSpeedCtrl[motorA] = mtrSpeedReg;motor[motorA] = 60; //Run motor A at 60 power level,
regardless of the conditions
Motors – 10 minute activityR
OB
OT
C F
EA
TU
RE
S
Try the following activities
1. Turn on the PID controller for the motors. Run the motors at speeds less than 100 (say 50%). Try varying the weight on the car by adding or removing something. Does it still run at the same speed? Do you see the PID controller working?
2. Repeat the activity done before (of spinning the car) by synchronizing the two motors in opposite direction
Sensor Interface - AdvancedR
OB
OT
C F
EA
TU
RE
SIn case the type of sensor need to be changed dynamically, based on some other input parameters, there are several other methods to configure sensors,
const tSensors sensor_name = sensor_port;SensorType[sensor_name] = sensor_type;
ParametersSensor_port – The input port to which the sensor is connected (S1, S2, S3 or S4)
Sensor_type – The type of configuration for the sensor (similar to dropdown menu on the previous slides)
Exampleconst tSensors myOtherTouchSensor = S3;SensorType[myOtherTouchSensor] = sensorTouch;
This command configures the input from port 3 to behave as a touch sensor input
Debugging – Sensor values revisitedR
OB
OT
C F
EA
TU
RE
S
Recall the previous discussion about the difference between the raw value and the sensor value.
In the following example, the same light sensor was connected to port 1 and under identical circumstances configured as an ‘active light sensor’ and a Sound sensor.
It can be clearly seen that despite the raw value being the same (as expected, due to the same circumstances), the sensor value is different, because it is configured differently
ExerciseE
XE
RC
ISE Write a program that has the capability of navigating the given
maze using just a touch sensor and the internal capability of the Lego motor to measure the angle. (Hint: its not as complex as it looks) start
finish
ExerciseE
XE
RC
ISE Can this navigation be done using just a single light sensor (no line to
follow here)? If yes, how? If not, then under what conditions or with what modifications to the maze would it be possible?
start
finish
ExerciseS
EC
TIO
N S
UM
MA
RY
Write a program that is capable of following a thin black line (around 1”) on a black background. Your program should be robust enough to do this task regardless of the shape that the line makes. The fastest team wins!