James Hilder / Pi_Swarm_Library_7

Unfinished v0.7, added bearing detection

Fork of Pi_Swarm_Library_v06_alpha by piswarm

piswarm.h@11:5ebcb52726cf, 2014-06-30 (annotated)

Committer:
jah128
Date:
Mon Jun 30 07:58:31 2014 +0000
Revision:
11:5ebcb52726cf
Parent:
10:5c111c07a2ed 
Added prototype bearing detection to pi swarm library;

Who changed what in which revision?

UserRevisionLine numberNew contents of line
jah128 4:52b3e4c5a425 1 /*******************************************************************************************
jah128 4:52b3e4c5a425 2 *
jah128 4:52b3e4c5a425 3 * University of York Robot Lab Pi Swarm Robot Library
jah128 0:9ffe8ebd1c40 4 *
jah128 0:9ffe8ebd1c40 5 * (C) Dr James Hilder, Dept. Electronics & Computer Science, University of York
jah128 0:9ffe8ebd1c40 6 *
jah128 9:7a4fc1d7e484 7 * Version 0.6 February 2014
jah128 9:7a4fc1d7e484 8 *
jah128 9:7a4fc1d7e484 9 * Change notes:
jah128 9:7a4fc1d7e484 10 * 0.6 : Added new IR sensor functions to improve efficiency (see manual for details)
jah128 9:7a4fc1d7e484 11 * 0.5 : Initial release
jah128 0:9ffe8ebd1c40 12 *
jah128 0:9ffe8ebd1c40 13 * Designed for use with the Pi Swarm Board (enhanced MBED sensor board) v1.2
jah128 0:9ffe8ebd1c40 14 *
jah128 4:52b3e4c5a425 15 ******************************************************************************************/
jah128 0:9ffe8ebd1c40 16
jah128 0:9ffe8ebd1c40 17 #ifndef PISWARM_H
jah128 0:9ffe8ebd1c40 18 #define PISWARM_H
jah128 0:9ffe8ebd1c40 19
jah128 0:9ffe8ebd1c40 20 #include "mbed.h"
jah128 0:9ffe8ebd1c40 21 #include "platform.h"
jah128 0:9ffe8ebd1c40 22 #include "alpha433.h"
jah128 0:9ffe8ebd1c40 23 #include "main.h"
jah128 0:9ffe8ebd1c40 24
jah128 0:9ffe8ebd1c40 25 #ifdef MBED_RPC
jah128 0:9ffe8ebd1c40 26 #include "rpc.h"
jah128 0:9ffe8ebd1c40 27 #endif
jah128 0:9ffe8ebd1c40 28
jah128 5:09d535cb9e9d 29 // The following defines are user parameters and may be edited
jah128 11:5ebcb52726cf 30 // USE_BEACON - if Pi Swarm table with IR beacon is used, set to 1 to allow sync on boot.
jah128 11:5ebcb52726cf 31 // DISPLAY_BEACON_READING - if value is 1, display shows beacon reading on each update
jah128 11:5ebcb52726cf 32 // CALIBRATE_MEMS - set to 1 to calibrate MEMS sensors on boot
jah128 5:09d535cb9e9d 33 // SWARM_SIZE - size of swarm (+1). Max 32.
jah128 5:09d535cb9e9d 34 // USE_COMMUNICATION_STACK - 1 to enable, 0 to bypass
jah128 5:09d535cb9e9d 35 // CALIBRATE_COLOURS - 1 to increase blue intensity, 0 to not
jah128 5:09d535cb9e9d 36 // CENTER_LED_BRIGHTNESS - Range 0 to 100
jah128 5:09d535cb9e9d 37 // OUTER_LED_BRIGHTNESS - Range 0 to 100
jah128 5:09d535cb9e9d 38 // PC_BAUD - PC Serial Baudrate. Max 115200
jah128 5:09d535cb9e9d 39 // RF_ALLOW_COMMANDS - 1 to allow remote RF commands, 0 to block
jah128 5:09d535cb9e9d 40 // RF_USE_LEDS - 1 to use MBED LEDs to display RF status
jah128 5:09d535cb9e9d 41 // RF_USE_TDMA - 1 to use time-delayed responses to broadcast messages
jah128 5:09d535cb9e9d 42 // RF_TDMA_TIME_PERIOD_US 15625 - Period of delay to use (per ID) in us.
jah128 5:09d535cb9e9d 43 // PISWARM_DEBUG - 1 to send general Pi Swarm debug information over USB serial interface
jah128 5:09d535cb9e9d 44 // RF_DEBUG - 1 to send communication stack debug information over USB serial interface
jah128 5:09d535cb9e9d 45 // RF_VERBOSE - 1 to send verbose RF debug information over USB serial interface
jah128 5:09d535cb9e9d 46 // START_RADIO_ON_BOOT - 1 to enable RF transceiver and comms stack on boot
jah128 5:09d535cb9e9d 47 // RF_FREQUENCY - Frequency of RF chip. See datasheet for details (default 435000000)
jah128 5:09d535cb9e9d 48 // RF_DATARATE - Baud rate of the RF chip. Max 115200, default 57600.
jah128 5:09d535cb9e9d 49
jah128 11:5ebcb52726cf 50 #define USE_BEACON 1
jah128 11:5ebcb52726cf 51 #define DISPLAY_BEACON_READING 1
jah128 11:5ebcb52726cf 52 #define CALIBRATE_MEMS 0
jah128 11:5ebcb52726cf 53 #define SLOW_TURN_LEFT_MULTIPLIER 5200
jah128 11:5ebcb52726cf 54 #define SLOW_TURN_RIGHT_MULTIPLIER 5450
jah128 11:5ebcb52726cf 55 #define SLOW_TURN_LEFT_OFFSET 1
jah128 11:5ebcb52726cf 56 #define SLOW_TURN_RIGHT_OFFSET 4
jah128 11:5ebcb52726cf 57 #define FAST_TURN_LEFT_MULTIPLIER 1450
jah128 11:5ebcb52726cf 58 #define FAST_TURN_RIGHT_MULTIPLIER 1450
jah128 5:09d535cb9e9d 59 #define SWARM_SIZE 32
jah128 11:5ebcb52726cf 60 #define USE_COMMUNICATION_STACK 0
jah128 5:09d535cb9e9d 61 #define CALIBRATE_COLOURS 1
jah128 5:09d535cb9e9d 62 #define CENTER_LED_BRIGHTNESS 30
jah128 5:09d535cb9e9d 63 #define OUTER_LED_BRIGHTNESS 50
jah128 5:09d535cb9e9d 64 #define PC_BAUD 115200
jah128 5:09d535cb9e9d 65 #define RF_ALLOW_COMMANDS 1
jah128 5:09d535cb9e9d 66 #define RF_USE_LEDS 1
jah128 5:09d535cb9e9d 67 #define RF_USE_TDMA 1
jah128 5:09d535cb9e9d 68 #define RF_TDMA_TIME_PERIOD_US 15625
jah128 5:09d535cb9e9d 69 #define PISWARM_DEBUG 1
jah128 11:5ebcb52726cf 70 #define RF_DEBUG 0
jah128 10:5c111c07a2ed 71 #define RF_VERBOSE 0
jah128 5:09d535cb9e9d 72 #define START_RADIO_ON_BOOT 1
jah128 5:09d535cb9e9d 73 #define RF_FREQUENCY 435000000
jah128 5:09d535cb9e9d 74 #define RF_DATARATE 57600
jah128 5:09d535cb9e9d 75
jah128 5:09d535cb9e9d 76 // The remaining defines give the addresses of hardware and 3-Pi instructions etc. and should not be changed
jah128 0:9ffe8ebd1c40 77 #define SEND_SIGNATURE 0x81
jah128 0:9ffe8ebd1c40 78 #define SEND_RAW_SENSOR_VALUES 0x86
jah128 0:9ffe8ebd1c40 79 #define SEND_TRIMPOT 0xB0
jah128 0:9ffe8ebd1c40 80 #define SEND_BATTERY_MILLIVOLTS 0xB1
jah128 0:9ffe8ebd1c40 81 #define DO_PLAY 0xB3
jah128 0:9ffe8ebd1c40 82 #define PI_CALIBRATE 0xB4
jah128 0:9ffe8ebd1c40 83 #define DO_CLEAR 0xB7
jah128 0:9ffe8ebd1c40 84 #define DO_PRINT 0xB8
jah128 0:9ffe8ebd1c40 85 #define DO_LCD_GOTO_XY 0xB9
jah128 0:9ffe8ebd1c40 86 #define LINE_SENSORS_RESET_CALIBRATION 0xB5
jah128 0:9ffe8ebd1c40 87 #define SEND_LINE_POSITION 0xB6
jah128 0:9ffe8ebd1c40 88 #define AUTO_CALIBRATE 0xBA
jah128 0:9ffe8ebd1c40 89 #define SET_PID 0xBB
jah128 0:9ffe8ebd1c40 90 #define STOP_PID 0xBC
jah128 0:9ffe8ebd1c40 91 #define M1_FORWARD 0xC1
jah128 0:9ffe8ebd1c40 92 #define M1_BACKWARD 0xC2
jah128 0:9ffe8ebd1c40 93 #define M2_FORWARD 0xC5
jah128 0:9ffe8ebd1c40 94 #define M2_BACKWARD 0xC6
jah128 0:9ffe8ebd1c40 95 #define EXPANSION_IC_ADDRESS 0x40
jah128 0:9ffe8ebd1c40 96 #define MAGNETOMETER_ADDRESS 0x1C
jah128 0:9ffe8ebd1c40 97 #define ADC_ADDRESS 0x46
jah128 0:9ffe8ebd1c40 98 #define EEPROM_ADDRESS 0XA0
jah128 0:9ffe8ebd1c40 99
jah128 0:9ffe8ebd1c40 100 class PiSwarm : public Stream {
jah128 0:9ffe8ebd1c40 101
jah128 0:9ffe8ebd1c40 102 // Public functions
jah128 0:9ffe8ebd1c40 103 public:
jah128 0:9ffe8ebd1c40 104
jah128 1:b067a08ff54e 105 // Create the Pi Swarm object connected to the default pins [see end of file]
jah128 0:9ffe8ebd1c40 106 PiSwarm();
jah128 4:52b3e4c5a425 107
jah128 4:52b3e4c5a425 108
jah128 4:52b3e4c5a425 109 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
jah128 4:52b3e4c5a425 110 // LED Functions
jah128 4:52b3e4c5a425 111 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
jah128 0:9ffe8ebd1c40 112
jah128 0:9ffe8ebd1c40 113 // Returns the RGB Colour of the Outer LED as an int (r<<16 g<<8 b)
jah128 0:9ffe8ebd1c40 114 int get_oled_colour(void);
jah128 0:9ffe8ebd1c40 115
jah128 1:b067a08ff54e 116 // Returns the enable state of an single outer led
jah128 1:b067a08ff54e 117 char get_oled_state(char oled);
jah128 1:b067a08ff54e 118
jah128 4:52b3e4c5a425 119 // Set colour of outer LEDs
jah128 4:52b3e4c5a425 120 void set_oled_colour ( char red, char green, char blue );
jah128 0:9ffe8ebd1c40 121
jah128 0:9ffe8ebd1c40 122 // Toggle the state of a single outer LED without affected the others
jah128 0:9ffe8ebd1c40 123 void set_oled(char oled, char value);
jah128 4:52b3e4c5a425 124
jah128 0:9ffe8ebd1c40 125 // Toggle the states of all 10 outer LEDs
jah128 0:9ffe8ebd1c40 126 void set_oleds(char oled_0, char oled_1, char oled_2, char oled_3, char oled_4, char oled_5, char oled_6, char oled_7, char oled_8, char oled_9);
jah128 0:9ffe8ebd1c40 127
jah128 4:52b3e4c5a425 128 // Disable all the LEDs and the dedicated power supply
jah128 4:52b3e4c5a425 129 void turn_off_all_oleds(void);
jah128 11:5ebcb52726cf 130
jah128 11:5ebcb52726cf 131 // Save the current colour and state of OLEDs [introduced in API 0.7]
jah128 11:5ebcb52726cf 132 void save_oled_state(void);
jah128 11:5ebcb52726cf 133
jah128 11:5ebcb52726cf 134 // Restore the saved colour and state of OLEDs [introduced in API 0.7]
jah128 11:5ebcb52726cf 135 void restore_oled_state(void);
jah128 4:52b3e4c5a425 136
jah128 4:52b3e4c5a425 137 // Set brightness of outer LEDs (works by increasing total period for PWM)
jah128 4:52b3e4c5a425 138 void set_oled_brightness ( char brightness );
jah128 4:52b3e4c5a425 139
jah128 4:52b3e4c5a425 140 // Sends the message to the GPIO expander to update which OLEDs are active
jah128 0:9ffe8ebd1c40 141 void activate_oleds(void);
jah128 0:9ffe8ebd1c40 142
jah128 4:52b3e4c5a425 143 // Returns the RGB Colour of the Center LED as an int (r<<16 g<<8 b)
jah128 4:52b3e4c5a425 144 int get_cled_colour(void);
jah128 4:52b3e4c5a425 145
jah128 4:52b3e4c5a425 146 // Returns the enable state of the center LED
jah128 4:52b3e4c5a425 147 char get_cled_state(void);
jah128 0:9ffe8ebd1c40 148
jah128 0:9ffe8ebd1c40 149 // Set colour of central LED
jah128 0:9ffe8ebd1c40 150 void set_cled_colour ( char red, char green, char blue );
jah128 4:52b3e4c5a425 151
jah128 4:52b3e4c5a425 152 // Enable or disable the center LED
jah128 4:52b3e4c5a425 153 void enable_cled ( char enable );
jah128 0:9ffe8ebd1c40 154
jah128 0:9ffe8ebd1c40 155 // Set brightness of central LED (works by increasing total period for PWM)
jah128 0:9ffe8ebd1c40 156 void set_cled_brightness ( char brightness );
jah128 0:9ffe8ebd1c40 157
jah128 4:52b3e4c5a425 158 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
jah128 4:52b3e4c5a425 159 // IR Functions
jah128 4:52b3e4c5a425 160 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
jah128 4:52b3e4c5a425 161
jah128 4:52b3e4c5a425 162 // Returns an approximate distance of any reflected obstacle in front of the given IR sensor (in millimeters, range 0 - 100)
jah128 0:9ffe8ebd1c40 163 float read_reflected_ir_distance ( char index );
jah128 0:9ffe8ebd1c40 164
jah128 9:7a4fc1d7e484 165 // Returns the stored value of the reflected obstacle based on last call of either read_reflected_ir_distance or store_reflected_distances
jah128 9:7a4fc1d7e484 166 // Introduced in API 0.6
jah128 9:7a4fc1d7e484 167 float get_reflected_ir_distance ( char index );
jah128 9:7a4fc1d7e484 168
jah128 9:7a4fc1d7e484 169 // Returns the stored value of the non-illuminated sensor based on last call of store_background_raw_ir_values
jah128 9:7a4fc1d7e484 170 // Introduced in API 0.6
jah128 9:7a4fc1d7e484 171 unsigned short get_background_raw_ir_value ( char index );
jah128 9:7a4fc1d7e484 172
jah128 9:7a4fc1d7e484 173 // Returns the stored value of the illuminated sensor based on last call of store_illuminated_raw_ir_values
jah128 9:7a4fc1d7e484 174 // Introduced in API 0.6
jah128 9:7a4fc1d7e484 175 unsigned short get_illuminated_raw_ir_value ( char index );
jah128 9:7a4fc1d7e484 176
jah128 9:7a4fc1d7e484 177 // Stores the reflected distances for all 8 IR sensors
jah128 9:7a4fc1d7e484 178 // Introduced in API 0.6
jah128 9:7a4fc1d7e484 179 void store_reflected_ir_distances ( void );
jah128 9:7a4fc1d7e484 180
jah128 9:7a4fc1d7e484 181 // Stores the raw ADC values for all 8 IR sensors without enabling IR emitters
jah128 9:7a4fc1d7e484 182 // Introduced in API 0.6
jah128 9:7a4fc1d7e484 183 void store_background_raw_ir_values ( void );
jah128 9:7a4fc1d7e484 184
jah128 9:7a4fc1d7e484 185 // Stores the raw ADC values for all 8 IR sensors with a 500us emitter pulse
jah128 9:7a4fc1d7e484 186 // Introduced in API 0.6
jah128 9:7a4fc1d7e484 187 void store_illuminated_raw_ir_values ( void );
jah128 9:7a4fc1d7e484 188
jah128 9:7a4fc1d7e484 189 // Converts a background and illuminated value into a distance
jah128 9:7a4fc1d7e484 190 // Introduced in API 0.6 - used by read_reflected_ir_distance and store_reflected_ir_distances
jah128 9:7a4fc1d7e484 191 float calculate_reflected_distance ( unsigned short background_value, unsigned short illuminated_value );
jah128 9:7a4fc1d7e484 192
jah128 3:4c0f2f3de33e 193 // Returns the illuminated raw ADC value for a given IR sensor (500us pulse)
jah128 3:4c0f2f3de33e 194 unsigned short read_illuminated_raw_ir_value ( char index );
jah128 3:4c0f2f3de33e 195
jah128 0:9ffe8ebd1c40 196 // Returns the raw ADC value for a given IR sensor
jah128 0:9ffe8ebd1c40 197 unsigned short read_adc_value( char index );
jah128 0:9ffe8ebd1c40 198
jah128 4:52b3e4c5a425 199 // Turns on or off the LDO outputs based on the current enable variables (enable_ir_ldo and enable_led_ldo)
jah128 4:52b3e4c5a425 200 void enable_ldo_outputs ( void );
jah128 4:52b3e4c5a425 201
jah128 4:52b3e4c5a425 202 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
jah128 4:52b3e4c5a425 203 // Sensor Functions
jah128 4:52b3e4c5a425 204 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
jah128 4:52b3e4c5a425 205
jah128 4:52b3e4c5a425 206 // Read the gyroscope yaw value. Return value is degrees per second clockwise.
jah128 4:52b3e4c5a425 207 float read_gyro ( void );
jah128 4:52b3e4c5a425 208
jah128 4:52b3e4c5a425 209 // Read the X value from the accelerometer. Return value is mps2.
jah128 4:52b3e4c5a425 210 float read_accelerometer_x ( void );
jah128 4:52b3e4c5a425 211
jah128 4:52b3e4c5a425 212 // Read the Y value from the accelerometer. Return value is mps2.
jah128 4:52b3e4c5a425 213 float read_accelerometer_y ( void );
jah128 4:52b3e4c5a425 214
jah128 4:52b3e4c5a425 215 // Read the Z value from the accelerometer. Return value is mps2. Generally this will have g against it.
jah128 4:52b3e4c5a425 216 float read_accelerometer_z ( void );
jah128 4:52b3e4c5a425 217
jah128 0:9ffe8ebd1c40 218 // Read the I2C magnetometer and store values locally: use before get_magnetometer_x etc...
jah128 0:9ffe8ebd1c40 219 char read_magnetometer ( void );
jah128 0:9ffe8ebd1c40 220
jah128 0:9ffe8ebd1c40 221 // Return the magnetometer x value stored on last call of read_magnetometer()
jah128 0:9ffe8ebd1c40 222 signed short get_magnetometer_x ( void );
jah128 0:9ffe8ebd1c40 223
jah128 0:9ffe8ebd1c40 224 // Return the magnetometer y value stored on last call of read_magnetometer()
jah128 0:9ffe8ebd1c40 225 signed short get_magnetometer_y ( void );
jah128 0:9ffe8ebd1c40 226
jah128 0:9ffe8ebd1c40 227 // Return the magnetometer z value stored on last call of read_magnetometer()
jah128 0:9ffe8ebd1c40 228 signed short get_magnetometer_z ( void );
jah128 0:9ffe8ebd1c40 229
jah128 4:52b3e4c5a425 230 // Read temperature from the temperature IC; return is temperature in degrees Celsius
jah128 4:52b3e4c5a425 231 float read_temperature ( void );
jah128 4:52b3e4c5a425 232
jah128 0:9ffe8ebd1c40 233 // Read the value from the light sensor. This will return a value ranging from 0 to a peak of around 100 in direct, bright light.
jah128 0:9ffe8ebd1c40 234 float read_light_sensor ( void );
jah128 0:9ffe8ebd1c40 235
jah128 4:52b3e4c5a425 236 // Read the raw line sensors into a 5-int array (range 0-2000)
jah128 4:52b3e4c5a425 237 void read_raw_sensors ( int * raw_ls_array );
jah128 4:52b3e4c5a425 238
jah128 4:52b3e4c5a425 239 // Returns the uptime of the system in seconds
jah128 4:52b3e4c5a425 240 float get_uptime (void);
jah128 4:52b3e4c5a425 241
jah128 4:52b3e4c5a425 242 // Returns the battery voltage
jah128 4:52b3e4c5a425 243 float battery(void);
jah128 4:52b3e4c5a425 244
jah128 4:52b3e4c5a425 245 // Read the voltage of the user potentiometer on the 3-pi
jah128 4:52b3e4c5a425 246 float pot_voltage(void);
jah128 4:52b3e4c5a425 247
jah128 0:9ffe8ebd1c40 248 // Read the robot ID set using the DIP switches (these are read during setup and not updated).
jah128 0:9ffe8ebd1c40 249 char get_id ( void );
jah128 0:9ffe8ebd1c40 250
jah128 0:9ffe8ebd1c40 251 // Read the switches value from the last call of the ISR
jah128 0:9ffe8ebd1c40 252 char get_switches ( void );
jah128 0:9ffe8ebd1c40 253
jah128 4:52b3e4c5a425 254 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
jah128 4:52b3e4c5a425 255 // Motor and Actuator Functions
jah128 4:52b3e4c5a425 256 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
jah128 4:52b3e4c5a425 257
jah128 4:52b3e4c5a425 258 // Returns the last speed value set for the left motor
jah128 4:52b3e4c5a425 259 float get_left_motor (void);
jah128 4:52b3e4c5a425 260
jah128 4:52b3e4c5a425 261 // Returns the last speed value set for the right motor
jah128 4:52b3e4c5a425 262 float get_right_motor (void);
jah128 4:52b3e4c5a425 263
jah128 4:52b3e4c5a425 264 // Directly control the speed and direction of the left motor (range -1.0 to 1.0)
jah128 4:52b3e4c5a425 265 void left_motor (float speed);
jah128 4:52b3e4c5a425 266
jah128 4:52b3e4c5a425 267 // Directly control the speed and direction of the right motor (range -1.0 to 1.0)
jah128 4:52b3e4c5a425 268 void right_motor (float speed);
jah128 4:52b3e4c5a425 269
jah128 4:52b3e4c5a425 270 // Drive both motors forward as the same speed (range -1.0 to 1.0)
jah128 4:52b3e4c5a425 271 void forward (float speed);
jah128 4:52b3e4c5a425 272
jah128 4:52b3e4c5a425 273 // Drive both motors backward as the same speed (range -1.0 to 1.0)
jah128 4:52b3e4c5a425 274 void backward (float speed);
jah128 4:52b3e4c5a425 275
jah128 4:52b3e4c5a425 276 // Drive left motor backwards and right motor forwards at the same speed to turn on the spot (range -1.0 to 1.0)
jah128 4:52b3e4c5a425 277 void left (float speed);
jah128 4:52b3e4c5a425 278
jah128 4:52b3e4c5a425 279 // Drive left motor forward and right motor backwards at the same speed to turn on the spot (range -1.0 to 1.0)
jah128 4:52b3e4c5a425 280 void right (float speed);
jah128 4:52b3e4c5a425 281
jah128 4:52b3e4c5a425 282 // Stop both motors
jah128 4:52b3e4c5a425 283 void stop (void);
jah128 0:9ffe8ebd1c40 284
jah128 4:52b3e4c5a425 285 // Play a tune on the 3-pi buzzer (see notes at end of file for more details)
jah128 4:52b3e4c5a425 286 void play_tune (char * tune, int length);
jah128 4:52b3e4c5a425 287
jah128 11:5ebcb52726cf 288 // Turn at slow speed (0.15) to the set amount of degrees (clockwise)
jah128 11:5ebcb52726cf 289 void slow_turn (float degrees);
jah128 11:5ebcb52726cf 290
jah128 11:5ebcb52726cf 291 // Turn at fast speed (0.5) to the set amount of degrees (clockwise)
jah128 11:5ebcb52726cf 292 void fast_turn (float degrees);
jah128 11:5ebcb52726cf 293
jah128 11:5ebcb52726cf 294 void test_turn_calibration(void);
jah128 11:5ebcb52726cf 295
jah128 4:52b3e4c5a425 296 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
jah128 4:52b3e4c5a425 297 // EEPROM Functions
jah128 4:52b3e4c5a425 298 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
jah128 4:52b3e4c5a425 299
jah128 0:9ffe8ebd1c40 300 // Write single byte to EEPROM
jah128 0:9ffe8ebd1c40 301 void write_eeprom_byte ( int address, char data );
jah128 0:9ffe8ebd1c40 302
jah128 0:9ffe8ebd1c40 303 // Write (length) bytes to EEPROM
jah128 0:9ffe8ebd1c40 304 void write_eeprom_block ( int address, char length, char * data);
jah128 0:9ffe8ebd1c40 305
jah128 0:9ffe8ebd1c40 306 // Read single byte from EEPROM
jah128 0:9ffe8ebd1c40 307 char read_eeprom_byte ( int address );
jah128 0:9ffe8ebd1c40 308
jah128 0:9ffe8ebd1c40 309 // Read next byte from EEPROM at current address
jah128 0:9ffe8ebd1c40 310 char read_next_eeprom_byte ( void );
jah128 0:9ffe8ebd1c40 311
jah128 0:9ffe8ebd1c40 312 // Read (length) from EEPROM
jah128 0:9ffe8ebd1c40 313 char read_eeprom_block ( int address, char length );
jah128 4:52b3e4c5a425 314
jah128 4:52b3e4c5a425 315 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
jah128 4:52b3e4c5a425 316 // Display Functions
jah128 4:52b3e4c5a425 317 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
jah128 4:52b3e4c5a425 318
jah128 4:52b3e4c5a425 319 // Locate the cursor on the 8x2 LCD [to position x (0-7), y (0-1)]
jah128 4:52b3e4c5a425 320 void locate(int x, int y);
jah128 0:9ffe8ebd1c40 321
jah128 4:52b3e4c5a425 322 // Clear the LCD
jah128 4:52b3e4c5a425 323 void cls(void);
jah128 4:52b3e4c5a425 324
jah128 4:52b3e4c5a425 325 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
jah128 4:52b3e4c5a425 326 // Setup and Internal Functions
jah128 4:52b3e4c5a425 327 // Generally these functions should not be called by user code
jah128 4:52b3e4c5a425 328 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
jah128 4:52b3e4c5a425 329
jah128 4:52b3e4c5a425 330 // Send a message of given length over the RF interface
jah128 4:52b3e4c5a425 331 void send_rf_message(char* message, char length);
jah128 4:52b3e4c5a425 332
jah128 4:52b3e4c5a425 333 // The default setup routine: called when the Pi Swarm is created
jah128 4:52b3e4c5a425 334 void setup ( void );
jah128 4:52b3e4c5a425 335
jah128 4:52b3e4c5a425 336 // Sets up the IO expansion IC using I2C commands; returns a zero if successful
jah128 4:52b3e4c5a425 337 int setup_expansion_ic ( void );
jah128 4:52b3e4c5a425 338
jah128 4:52b3e4c5a425 339 // Called after a delay from the IO expansion interrupt; delay helps debounce switches
jah128 4:52b3e4c5a425 340 void interrupt_timeout_event ( void );
jah128 0:9ffe8ebd1c40 341
jah128 4:52b3e4c5a425 342 // The interrupt handler for the IO expansion IC; calls the timeout event to debounce switches
jah128 4:52b3e4c5a425 343 void expansion_interrupt_handler ( void );
jah128 4:52b3e4c5a425 344
jah128 4:52b3e4c5a425 345 // Turns off interrupt LED after a delay to indicate switch has been pressed
jah128 4:52b3e4c5a425 346 void led_timeout_event ( void );
jah128 4:52b3e4c5a425 347
jah128 4:52b3e4c5a425 348 // Routine to calibrate gyro; by default run in setup, robot should be stationary to avoid errors (Returns 1 if successful, 0 if failed)
jah128 4:52b3e4c5a425 349 char calibrate_gyro ( void );
jah128 4:52b3e4c5a425 350
jah128 4:52b3e4c5a425 351 // Routine to calibrate accelerometer, by default run after successful gyro calibration, robot should be flat and stationary to avoid errors (Returns 1 if successful, 0 if failed)
jah128 4:52b3e4c5a425 352 char calibrate_accelerometer ( void );
jah128 0:9ffe8ebd1c40 353
jah128 4:52b3e4c5a425 354 // Routine to calibrate magnetometer (Returns 1 if successful, 0 if failed)
jah128 4:52b3e4c5a425 355 char calibrate_magnetometer ( void );
jah128 4:52b3e4c5a425 356
jah128 4:52b3e4c5a425 357 // Send instructions to the I2C ADC (for IR measurement)
jah128 4:52b3e4c5a425 358 char setup_adc( void );
jah128 4:52b3e4c5a425 359
jah128 4:52b3e4c5a425 360 // Routine to initialise radio
jah128 4:52b3e4c5a425 361 void setup_radio( void );
jah128 4:52b3e4c5a425 362
jah128 4:52b3e4c5a425 363 // Blinks the calibration LED during calibration (turns off if calibration successful)
jah128 4:52b3e4c5a425 364 void calibrate_ticker_routine ( void );
jah128 0:9ffe8ebd1c40 365
jah128 4:52b3e4c5a425 366 // Used to debug/test the OLED array
jah128 4:52b3e4c5a425 367 void test_oled(void);
jah128 4:52b3e4c5a425 368
jah128 4:52b3e4c5a425 369 // Starts the system timer
jah128 4:52b3e4c5a425 370 void start_system_timer(void);
jah128 4:52b3e4c5a425 371
jah128 4:52b3e4c5a425 372 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
jah128 4:52b3e4c5a425 373 // Native m3Pi Functions
jah128 9:7a4fc1d7e484 374 // These should preserve functionality of (most) m3pi code but may not be fully functional on Pi Swarm
jah128 4:52b3e4c5a425 375 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
jah128 4:52b3e4c5a425 376
jah128 1:b067a08ff54e 377 // Force a hardware reset of the 3-pi
jah128 0:9ffe8ebd1c40 378 void reset (void);
jah128 0:9ffe8ebd1c40 379
jah128 4:52b3e4c5a425 380 // Read the position of the detected line [using line-following IR]
jah128 0:9ffe8ebd1c40 381 float line_position (void);
jah128 0:9ffe8ebd1c40 382
jah128 4:52b3e4c5a425 383 // Calibrate the sensors. This turns the robot left then right, looking for a line [using line-following IR]
jah128 0:9ffe8ebd1c40 384 char sensor_auto_calibrate (void);
jah128 0:9ffe8ebd1c40 385
jah128 4:52b3e4c5a425 386 // Set calibration manually to the current settings.
jah128 0:9ffe8ebd1c40 387 void calibrate(void);
jah128 0:9ffe8ebd1c40 388
jah128 4:52b3e4c5a425 389 // Clear the current calibration settings
jah128 0:9ffe8ebd1c40 390 void reset_calibration (void);
jah128 0:9ffe8ebd1c40 391
jah128 4:52b3e4c5a425 392 // Start the PID contoller
jah128 0:9ffe8ebd1c40 393 void PID_start(int max_speed, int a, int b, int c, int d);
jah128 0:9ffe8ebd1c40 394
jah128 4:52b3e4c5a425 395 // Stop the PID controller
jah128 0:9ffe8ebd1c40 396 void PID_stop();
jah128 0:9ffe8ebd1c40 397
jah128 4:52b3e4c5a425 398 // Send a character directly to the 3pi serial interface
jah128 0:9ffe8ebd1c40 399 int putc(int c);
jah128 0:9ffe8ebd1c40 400
jah128 4:52b3e4c5a425 401 // Receive a character directly to the 3pi serial interface
jah128 0:9ffe8ebd1c40 402 int getc();
jah128 0:9ffe8ebd1c40 403
jah128 4:52b3e4c5a425 404 // Send a string buffer to the 3pi serial interface
jah128 0:9ffe8ebd1c40 405 int print(char* text, int length);
jah128 0:9ffe8ebd1c40 406
jah128 4:52b3e4c5a425 407 #ifdef MBED_RPC
jah128 4:52b3e4c5a425 408 virtual const struct rpc_method *get_rpc_methods();
jah128 4:52b3e4c5a425 409 #endif
jah128 0:9ffe8ebd1c40 410
jah128 4:52b3e4c5a425 411 private :
jah128 0:9ffe8ebd1c40 412
jah128 0:9ffe8ebd1c40 413 Serial _ser;
jah128 0:9ffe8ebd1c40 414 PwmOut _oled_r, _oled_g, _oled_b, _cled_r, _cled_g, _cled_b;
jah128 0:9ffe8ebd1c40 415 AnalogIn _gyro, _accel_x, _accel_y, _accel_z, _temperature, _light;
jah128 4:52b3e4c5a425 416 I2C _i2c;
jah128 0:9ffe8ebd1c40 417 DigitalOut _irpulse_1, _irpulse_2;
jah128 0:9ffe8ebd1c40 418 Alpha433 _rf;
jah128 0:9ffe8ebd1c40 419 Timer _system_timer;
jah128 0:9ffe8ebd1c40 420
jah128 0:9ffe8ebd1c40 421 void motor (int motor, float speed);
jah128 0:9ffe8ebd1c40 422 virtual int _putc(int c);
jah128 0:9ffe8ebd1c40 423 virtual int _getc();
jah128 0:9ffe8ebd1c40 424
jah128 0:9ffe8ebd1c40 425 };
jah128 0:9ffe8ebd1c40 426
jah128 11:5ebcb52726cf 427 void display_bearing_info(void);
jah128 11:5ebcb52726cf 428 void resync_with_beacon(void);
jah128 11:5ebcb52726cf 429 void update_bearing(void);
jah128 11:5ebcb52726cf 430 void highlight_bearing(void);
jah128 0:9ffe8ebd1c40 431 void display_system_time(void);
jah128 0:9ffe8ebd1c40 432 void init(void);
jah128 0:9ffe8ebd1c40 433 extern Serial pc;
jah128 0:9ffe8ebd1c40 434 extern PiSwarm piswarm;
jah128 0:9ffe8ebd1c40 435
jah128 0:9ffe8ebd1c40 436 #endif
jah128 0:9ffe8ebd1c40 437
jah128 6:69a48b1ec3af 438
jah128 1:b067a08ff54e 439 /********************************************************************************
jah128 1:b067a08ff54e 440 * MBED Pin connection layout *
jah128 1:b067a08ff54e 441 * *
jah128 1:b067a08ff54e 442 * * Pin 05 : Alpha Transceiver SDI *
jah128 1:b067a08ff54e 443 * * Pin 06 : Alpha Transceiver SDO *
jah128 1:b067a08ff54e 444 * * Pin 07 : Alpha Transceiver CLK *
jah128 1:b067a08ff54e 445 * * Pin 08 : Alpha Transceiver FSS *
jah128 1:b067a08ff54e 446 * * Pin 09 : Serial (3pi) transmit *
jah128 1:b067a08ff54e 447 * * Pin 10 : Serial (3pi) receive *
jah128 1:b067a08ff54e 448 * * Pin 11 : Alpha Transceiver NIRQ *
jah128 1:b067a08ff54e 449 * * Pin 12 : IR Pulse Output for IR1,2,7,8 *
jah128 1:b067a08ff54e 450 * * Pin 13 : IR Pulse Output for IR3,4,5,6 *
jah128 1:b067a08ff54e 451 * * Pin 14 : Echo Pin for Sonar *
jah128 1:b067a08ff54e 452 * * Pin 15 : Light Sensor Analogue Input *
jah128 1:b067a08ff54e 453 * * Pin 16 : Gyrometer Analogue Input *
jah128 1:b067a08ff54e 454 * * Pin 17 : Accelerometer Z Analogue Input *
jah128 1:b067a08ff54e 455 * * Pin 18 : Accelerometer Y Analogue Input *
jah128 1:b067a08ff54e 456 * * Pin 19 : Accelerometer X Analogue Input *
jah128 1:b067a08ff54e 457 * * Pin 20 : Temperature Sensor Analogue Input *
jah128 1:b067a08ff54e 458 * * Pin 21 : Center LED Blue PWM Output *
jah128 1:b067a08ff54e 459 * * Pin 22 : Center LED Green PWM Output *
jah128 1:b067a08ff54e 460 * * Pin 23 : Center LED Red PWM Output *
jah128 1:b067a08ff54e 461 * * Pin 24 : Outer LED Blue PWM Output *
jah128 1:b067a08ff54e 462 * * Pin 25 : Outer LED Green PWM Output *
jah128 1:b067a08ff54e 463 * * Pin 26 : Outer LED Red PWM Output *
jah128 1:b067a08ff54e 464 * * Pin 27 : I2C SCL *
jah128 1:b067a08ff54e 465 * * Pin 28 : I2C SDA *
jah128 1:b067a08ff54e 466 * * Pin 29 : GPIO Expander Interrupt *
jah128 1:b067a08ff54e 467 * * Pin 30 : Trigger Pin for Sonar *
jah128 1:b067a08ff54e 468 * * Pin 31 : USB D+ Connector *
jah128 1:b067a08ff54e 469 * * Pin 32 : USB D- Connector *
jah128 1:b067a08ff54e 470 * *
jah128 1:b067a08ff54e 471 *******************************************************************************/
jah128 0:9ffe8ebd1c40 472
jah128 0:9ffe8ebd1c40 473 /********************************************************************************
jah128 1:b067a08ff54e 474 * Using the 3-Pi Buzzer *
jah128 1:b067a08ff54e 475 * *
jah128 1:b067a08ff54e 476 * play_tune (char * tune, int length) *
jah128 1:b067a08ff54e 477 * *
jah128 1:b067a08ff54e 478 * tune - Pointer to a character sequence of the tune *
jah128 1:b067a08ff54e 479 * length - Length of characters in sequence *
jah128 1:b067a08ff54e 480 * *
jah128 1:b067a08ff54e 481 * The character sequence recognises the following characters: *
jah128 1:b067a08ff54e 482 * *
jah128 1:b067a08ff54e 483 * A – G : used to specify the notes that will be played *
jah128 1:b067a08ff54e 484 * *
jah128 1:b067a08ff54e 485 * R : used to specify a rest (no sound for the duration of the note) *
jah128 1:b067a08ff54e 486 * *
jah128 1:b067a08ff54e 487 * < or > : plays the next note one octave lower or higher *
jah128 1:b067a08ff54e 488 * *
jah128 1:b067a08ff54e 489 * + or # : raises the previous notes pitch by one semitone *
jah128 1:b067a08ff54e 490 * *
jah128 1:b067a08ff54e 491 * - : lowers the previous note pitch by one semitone *
jah128 1:b067a08ff54e 492 * *
jah128 1:b067a08ff54e 493 * . : extend length of previous by 50% (each additional dot adds half as *
jah128 1:b067a08ff54e 494 * much as the previous dot, so that A.. is 1.75 times the length of A *
jah128 1:b067a08ff54e 495 * *
jah128 1:b067a08ff54e 496 * O followed by a number : sets the octave (default : O4) *
jah128 1:b067a08ff54e 497 * *
jah128 1:b067a08ff54e 498 * T followed by a number : sets the tempo in beats/min (default : T120) *
jah128 1:b067a08ff54e 499 * *
jah128 1:b067a08ff54e 500 * L followed by a number : sets the default note duration specified by the*
jah128 1:b067a08ff54e 501 * number - 4 for quarter notes, 8 for eighth, 16 *
jah128 1:b067a08ff54e 502 * for sixteenth notes, etc. (default : L4) *
jah128 1:b067a08ff54e 503 * *
jah128 1:b067a08ff54e 504 * V followed by a number : sets the volume (range 0 - 15, default : V15) *
jah128 1:b067a08ff54e 505 * *
jah128 1:b067a08ff54e 506 * MS : sets all subsequent notes to play staccato (each note is played for*
jah128 1:b067a08ff54e 507 * 1/2 of its allotted time followed by an equal period of silence) *
jah128 1:b067a08ff54e 508 * *
jah128 1:b067a08ff54e 509 * ML : sets all subsequent notes to play legato (each note is played for *
jah128 1:b067a08ff54e 510 * full length. This is the default setting. *
jah128 1:b067a08ff54e 511 * *
jah128 1:b067a08ff54e 512 * ! : resets the octave, tempo, duration, volume, and staccato setting to *
jah128 1:b067a08ff54e 513 * their default values. These settings persist from one play_tune() to*
jah128 1:b067a08ff54e 514 * the next, which allows you to more conveniently break up your music *
jah128 1:b067a08ff54e 515 * into reusable sections. *
jah128 1:b067a08ff54e 516 * *
jah128 1:b067a08ff54e 517 * 1 - 2000 : when immediately following a note, a number determines the *
jah128 1:b067a08ff54e 518 * duration of the note. For example, C16 specifies C played as *
jah128 1:b067a08ff54e 519 * a sixteenth note (1/16th the length of a whole note). *
jah128 1:b067a08ff54e 520 * *
jah128 1:b067a08ff54e 521 * *
jah128 1:b067a08ff54e 522 * Some examples: *
jah128 1:b067a08ff54e 523 * *
jah128 1:b067a08ff54e 524 * Blue Danube Waltz (played badly!) *
jah128 1:b067a08ff54e 525 * play_tune("MSCEGGR>F>FR>D>DRCCEGGR>G>GR>E>ER<B<BDAAR>A>AR>F>F",51); *
jah128 1:b067a08ff54e 526 * *
jah128 1:b067a08ff54e 527 *******************************************************************************/
jah128 1:b067a08ff54e 528
jah128 1:b067a08ff54e 529 /********************************************************************************
jah128 0:9ffe8ebd1c40 530 * COPYRIGHT NOTICE *
jah128 0:9ffe8ebd1c40 531 * *
jah128 4:52b3e4c5a425 532 * *
jah128 4:52b3e4c5a425 533 * Parts of code based on the original m3pi library, Copyright (c) 2010 cstyles *
jah128 4:52b3e4c5a425 534 * *
jah128 0:9ffe8ebd1c40 535 * Permission is hereby granted, free of charge, to any person obtaining a copy *
jah128 0:9ffe8ebd1c40 536 * of this software and associated documentation files (the "Software"), to deal*
jah128 0:9ffe8ebd1c40 537 * in the Software without restriction, including without limitation the rights *
jah128 0:9ffe8ebd1c40 538 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell *
jah128 0:9ffe8ebd1c40 539 * copies of the Software, and to permit persons to whom the Software is *
jah128 0:9ffe8ebd1c40 540 * furnished to do so, subject to the following conditions: *
jah128 0:9ffe8ebd1c40 541 * *
jah128 0:9ffe8ebd1c40 542 * The above copyright notice and this permission notice shall be included in *
jah128 0:9ffe8ebd1c40 543 * all copies or substantial portions of the Software. *
jah128 0:9ffe8ebd1c40 544 * *
jah128 0:9ffe8ebd1c40 545 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR *
jah128 0:9ffe8ebd1c40 546 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, *
jah128 0:9ffe8ebd1c40 547 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE *
jah128 0:9ffe8ebd1c40 548 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER *
jah128 0:9ffe8ebd1c40 549 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,*
jah128 0:9ffe8ebd1c40 550 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN *
jah128 0:9ffe8ebd1c40 551 * THE SOFTWARE. *
jah128 0:9ffe8ebd1c40 552 * *
jah128 0:9ffe8ebd1c40 553 *******************************************************************************/