Unfinished version 0.6 library for the Pi Swarm robot. NOTE: This library is not yet finished or fully tested - it will change.
Dependents: Pi_Swarm_Blank Aggregation-Flocking_2 Pi_Swarm_User_Command_RF_Test
Fork of Pi_Swarm_Library by
piswarm.h@4:52b3e4c5a425, 2014-02-02 (annotated)
- Committer:
- jah128
- Date:
- Sun Feb 02 22:30:47 2014 +0000
- Revision:
- 4:52b3e4c5a425
- Parent:
- 3:4c0f2f3de33e
- Child:
- 5:09d535cb9e9d
Fixed warnings;
Who changed what in which revision?
User | Revision | Line number | New 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 | 4:52b3e4c5a425 | 7 | * Version 0.5 February 2014 |
jah128 | 0:9ffe8ebd1c40 | 8 | * |
jah128 | 0:9ffe8ebd1c40 | 9 | * Designed for use with the Pi Swarm Board (enhanced MBED sensor board) v1.2 |
jah128 | 0:9ffe8ebd1c40 | 10 | * |
jah128 | 4:52b3e4c5a425 | 11 | ******************************************************************************************/ |
jah128 | 0:9ffe8ebd1c40 | 12 | |
jah128 | 0:9ffe8ebd1c40 | 13 | #ifndef PISWARM_H |
jah128 | 0:9ffe8ebd1c40 | 14 | #define PISWARM_H |
jah128 | 0:9ffe8ebd1c40 | 15 | |
jah128 | 0:9ffe8ebd1c40 | 16 | #include "mbed.h" |
jah128 | 0:9ffe8ebd1c40 | 17 | #include "platform.h" |
jah128 | 0:9ffe8ebd1c40 | 18 | #include "alpha433.h" |
jah128 | 0:9ffe8ebd1c40 | 19 | #include "main.h" |
jah128 | 0:9ffe8ebd1c40 | 20 | |
jah128 | 0:9ffe8ebd1c40 | 21 | #ifdef MBED_RPC |
jah128 | 0:9ffe8ebd1c40 | 22 | #include "rpc.h" |
jah128 | 0:9ffe8ebd1c40 | 23 | #endif |
jah128 | 0:9ffe8ebd1c40 | 24 | |
jah128 | 0:9ffe8ebd1c40 | 25 | #define SEND_SIGNATURE 0x81 |
jah128 | 0:9ffe8ebd1c40 | 26 | #define SEND_RAW_SENSOR_VALUES 0x86 |
jah128 | 0:9ffe8ebd1c40 | 27 | #define SEND_TRIMPOT 0xB0 |
jah128 | 0:9ffe8ebd1c40 | 28 | #define SEND_BATTERY_MILLIVOLTS 0xB1 |
jah128 | 0:9ffe8ebd1c40 | 29 | #define DO_PLAY 0xB3 |
jah128 | 0:9ffe8ebd1c40 | 30 | #define PI_CALIBRATE 0xB4 |
jah128 | 0:9ffe8ebd1c40 | 31 | #define DO_CLEAR 0xB7 |
jah128 | 0:9ffe8ebd1c40 | 32 | #define DO_PRINT 0xB8 |
jah128 | 0:9ffe8ebd1c40 | 33 | #define DO_LCD_GOTO_XY 0xB9 |
jah128 | 0:9ffe8ebd1c40 | 34 | #define LINE_SENSORS_RESET_CALIBRATION 0xB5 |
jah128 | 0:9ffe8ebd1c40 | 35 | #define SEND_LINE_POSITION 0xB6 |
jah128 | 0:9ffe8ebd1c40 | 36 | #define AUTO_CALIBRATE 0xBA |
jah128 | 0:9ffe8ebd1c40 | 37 | #define SET_PID 0xBB |
jah128 | 0:9ffe8ebd1c40 | 38 | #define STOP_PID 0xBC |
jah128 | 0:9ffe8ebd1c40 | 39 | #define M1_FORWARD 0xC1 |
jah128 | 0:9ffe8ebd1c40 | 40 | #define M1_BACKWARD 0xC2 |
jah128 | 0:9ffe8ebd1c40 | 41 | #define M2_FORWARD 0xC5 |
jah128 | 0:9ffe8ebd1c40 | 42 | #define M2_BACKWARD 0xC6 |
jah128 | 0:9ffe8ebd1c40 | 43 | #define EXPANSION_IC_ADDRESS 0x40 |
jah128 | 0:9ffe8ebd1c40 | 44 | #define MAGNETOMETER_ADDRESS 0x1C |
jah128 | 0:9ffe8ebd1c40 | 45 | #define ADC_ADDRESS 0x46 |
jah128 | 0:9ffe8ebd1c40 | 46 | #define EEPROM_ADDRESS 0XA0 |
jah128 | 0:9ffe8ebd1c40 | 47 | |
jah128 | 0:9ffe8ebd1c40 | 48 | class PiSwarm : public Stream { |
jah128 | 0:9ffe8ebd1c40 | 49 | |
jah128 | 0:9ffe8ebd1c40 | 50 | // Public functions |
jah128 | 0:9ffe8ebd1c40 | 51 | public: |
jah128 | 0:9ffe8ebd1c40 | 52 | |
jah128 | 1:b067a08ff54e | 53 | // Create the Pi Swarm object connected to the default pins [see end of file] |
jah128 | 0:9ffe8ebd1c40 | 54 | PiSwarm(); |
jah128 | 4:52b3e4c5a425 | 55 | |
jah128 | 4:52b3e4c5a425 | 56 | |
jah128 | 4:52b3e4c5a425 | 57 | ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// |
jah128 | 4:52b3e4c5a425 | 58 | // LED Functions |
jah128 | 4:52b3e4c5a425 | 59 | ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// |
jah128 | 0:9ffe8ebd1c40 | 60 | |
jah128 | 0:9ffe8ebd1c40 | 61 | // Returns the RGB Colour of the Outer LED as an int (r<<16 g<<8 b) |
jah128 | 0:9ffe8ebd1c40 | 62 | int get_oled_colour(void); |
jah128 | 0:9ffe8ebd1c40 | 63 | |
jah128 | 1:b067a08ff54e | 64 | // Returns the enable state of an single outer led |
jah128 | 1:b067a08ff54e | 65 | char get_oled_state(char oled); |
jah128 | 1:b067a08ff54e | 66 | |
jah128 | 4:52b3e4c5a425 | 67 | // Set colour of outer LEDs |
jah128 | 4:52b3e4c5a425 | 68 | void set_oled_colour ( char red, char green, char blue ); |
jah128 | 0:9ffe8ebd1c40 | 69 | |
jah128 | 0:9ffe8ebd1c40 | 70 | // Toggle the state of a single outer LED without affected the others |
jah128 | 0:9ffe8ebd1c40 | 71 | void set_oled(char oled, char value); |
jah128 | 4:52b3e4c5a425 | 72 | |
jah128 | 0:9ffe8ebd1c40 | 73 | // Toggle the states of all 10 outer LEDs |
jah128 | 0:9ffe8ebd1c40 | 74 | 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 | 75 | |
jah128 | 4:52b3e4c5a425 | 76 | // Disable all the LEDs and the dedicated power supply |
jah128 | 4:52b3e4c5a425 | 77 | void turn_off_all_oleds(void); |
jah128 | 4:52b3e4c5a425 | 78 | |
jah128 | 4:52b3e4c5a425 | 79 | // Set brightness of outer LEDs (works by increasing total period for PWM) |
jah128 | 4:52b3e4c5a425 | 80 | void set_oled_brightness ( char brightness ); |
jah128 | 4:52b3e4c5a425 | 81 | |
jah128 | 4:52b3e4c5a425 | 82 | // Sends the message to the GPIO expander to update which OLEDs are active |
jah128 | 0:9ffe8ebd1c40 | 83 | void activate_oleds(void); |
jah128 | 0:9ffe8ebd1c40 | 84 | |
jah128 | 4:52b3e4c5a425 | 85 | // Returns the RGB Colour of the Center LED as an int (r<<16 g<<8 b) |
jah128 | 4:52b3e4c5a425 | 86 | int get_cled_colour(void); |
jah128 | 4:52b3e4c5a425 | 87 | |
jah128 | 4:52b3e4c5a425 | 88 | // Returns the enable state of the center LED |
jah128 | 4:52b3e4c5a425 | 89 | char get_cled_state(void); |
jah128 | 0:9ffe8ebd1c40 | 90 | |
jah128 | 0:9ffe8ebd1c40 | 91 | // Set colour of central LED |
jah128 | 0:9ffe8ebd1c40 | 92 | void set_cled_colour ( char red, char green, char blue ); |
jah128 | 4:52b3e4c5a425 | 93 | |
jah128 | 4:52b3e4c5a425 | 94 | // Enable or disable the center LED |
jah128 | 4:52b3e4c5a425 | 95 | void enable_cled ( char enable ); |
jah128 | 0:9ffe8ebd1c40 | 96 | |
jah128 | 0:9ffe8ebd1c40 | 97 | // Set brightness of central LED (works by increasing total period for PWM) |
jah128 | 0:9ffe8ebd1c40 | 98 | void set_cled_brightness ( char brightness ); |
jah128 | 0:9ffe8ebd1c40 | 99 | |
jah128 | 4:52b3e4c5a425 | 100 | ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// |
jah128 | 4:52b3e4c5a425 | 101 | // IR Functions |
jah128 | 4:52b3e4c5a425 | 102 | ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// |
jah128 | 4:52b3e4c5a425 | 103 | |
jah128 | 4:52b3e4c5a425 | 104 | // Returns an approximate distance of any reflected obstacle in front of the given IR sensor (in millimeters, range 0 - 100) |
jah128 | 0:9ffe8ebd1c40 | 105 | float read_reflected_ir_distance ( char index ); |
jah128 | 0:9ffe8ebd1c40 | 106 | |
jah128 | 3:4c0f2f3de33e | 107 | // Returns the illuminated raw ADC value for a given IR sensor (500us pulse) |
jah128 | 3:4c0f2f3de33e | 108 | unsigned short read_illuminated_raw_ir_value ( char index ); |
jah128 | 3:4c0f2f3de33e | 109 | |
jah128 | 0:9ffe8ebd1c40 | 110 | // Returns the raw ADC value for a given IR sensor |
jah128 | 0:9ffe8ebd1c40 | 111 | unsigned short read_adc_value( char index ); |
jah128 | 0:9ffe8ebd1c40 | 112 | |
jah128 | 4:52b3e4c5a425 | 113 | // Turns on or off the LDO outputs based on the current enable variables (enable_ir_ldo and enable_led_ldo) |
jah128 | 4:52b3e4c5a425 | 114 | void enable_ldo_outputs ( void ); |
jah128 | 4:52b3e4c5a425 | 115 | |
jah128 | 4:52b3e4c5a425 | 116 | ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// |
jah128 | 4:52b3e4c5a425 | 117 | // Sensor Functions |
jah128 | 4:52b3e4c5a425 | 118 | ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// |
jah128 | 4:52b3e4c5a425 | 119 | |
jah128 | 4:52b3e4c5a425 | 120 | // Read the gyroscope yaw value. Return value is degrees per second clockwise. |
jah128 | 4:52b3e4c5a425 | 121 | float read_gyro ( void ); |
jah128 | 4:52b3e4c5a425 | 122 | |
jah128 | 4:52b3e4c5a425 | 123 | // Read the X value from the accelerometer. Return value is mps2. |
jah128 | 4:52b3e4c5a425 | 124 | float read_accelerometer_x ( void ); |
jah128 | 4:52b3e4c5a425 | 125 | |
jah128 | 4:52b3e4c5a425 | 126 | // Read the Y value from the accelerometer. Return value is mps2. |
jah128 | 4:52b3e4c5a425 | 127 | float read_accelerometer_y ( void ); |
jah128 | 4:52b3e4c5a425 | 128 | |
jah128 | 4:52b3e4c5a425 | 129 | // Read the Z value from the accelerometer. Return value is mps2. Generally this will have g against it. |
jah128 | 4:52b3e4c5a425 | 130 | float read_accelerometer_z ( void ); |
jah128 | 4:52b3e4c5a425 | 131 | |
jah128 | 0:9ffe8ebd1c40 | 132 | // Read the I2C magnetometer and store values locally: use before get_magnetometer_x etc... |
jah128 | 0:9ffe8ebd1c40 | 133 | char read_magnetometer ( void ); |
jah128 | 0:9ffe8ebd1c40 | 134 | |
jah128 | 0:9ffe8ebd1c40 | 135 | // Return the magnetometer x value stored on last call of read_magnetometer() |
jah128 | 0:9ffe8ebd1c40 | 136 | signed short get_magnetometer_x ( void ); |
jah128 | 0:9ffe8ebd1c40 | 137 | |
jah128 | 0:9ffe8ebd1c40 | 138 | // Return the magnetometer y value stored on last call of read_magnetometer() |
jah128 | 0:9ffe8ebd1c40 | 139 | signed short get_magnetometer_y ( void ); |
jah128 | 0:9ffe8ebd1c40 | 140 | |
jah128 | 0:9ffe8ebd1c40 | 141 | // Return the magnetometer z value stored on last call of read_magnetometer() |
jah128 | 0:9ffe8ebd1c40 | 142 | signed short get_magnetometer_z ( void ); |
jah128 | 0:9ffe8ebd1c40 | 143 | |
jah128 | 4:52b3e4c5a425 | 144 | // Read temperature from the temperature IC; return is temperature in degrees Celsius |
jah128 | 4:52b3e4c5a425 | 145 | float read_temperature ( void ); |
jah128 | 4:52b3e4c5a425 | 146 | |
jah128 | 0:9ffe8ebd1c40 | 147 | // 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 | 148 | float read_light_sensor ( void ); |
jah128 | 0:9ffe8ebd1c40 | 149 | |
jah128 | 4:52b3e4c5a425 | 150 | // Read the raw line sensors into a 5-int array (range 0-2000) |
jah128 | 4:52b3e4c5a425 | 151 | void read_raw_sensors ( int * raw_ls_array ); |
jah128 | 4:52b3e4c5a425 | 152 | |
jah128 | 4:52b3e4c5a425 | 153 | // Returns the uptime of the system in seconds |
jah128 | 4:52b3e4c5a425 | 154 | float get_uptime (void); |
jah128 | 4:52b3e4c5a425 | 155 | |
jah128 | 4:52b3e4c5a425 | 156 | // Returns the battery voltage |
jah128 | 4:52b3e4c5a425 | 157 | float battery(void); |
jah128 | 4:52b3e4c5a425 | 158 | |
jah128 | 4:52b3e4c5a425 | 159 | // Read the voltage of the user potentiometer on the 3-pi |
jah128 | 4:52b3e4c5a425 | 160 | float pot_voltage(void); |
jah128 | 4:52b3e4c5a425 | 161 | |
jah128 | 0:9ffe8ebd1c40 | 162 | // Read the robot ID set using the DIP switches (these are read during setup and not updated). |
jah128 | 0:9ffe8ebd1c40 | 163 | char get_id ( void ); |
jah128 | 0:9ffe8ebd1c40 | 164 | |
jah128 | 0:9ffe8ebd1c40 | 165 | // Read the switches value from the last call of the ISR |
jah128 | 0:9ffe8ebd1c40 | 166 | char get_switches ( void ); |
jah128 | 0:9ffe8ebd1c40 | 167 | |
jah128 | 4:52b3e4c5a425 | 168 | ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// |
jah128 | 4:52b3e4c5a425 | 169 | // Motor and Actuator Functions |
jah128 | 4:52b3e4c5a425 | 170 | ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// |
jah128 | 4:52b3e4c5a425 | 171 | |
jah128 | 4:52b3e4c5a425 | 172 | // Returns the last speed value set for the left motor |
jah128 | 4:52b3e4c5a425 | 173 | float get_left_motor (void); |
jah128 | 4:52b3e4c5a425 | 174 | |
jah128 | 4:52b3e4c5a425 | 175 | // Returns the last speed value set for the right motor |
jah128 | 4:52b3e4c5a425 | 176 | float get_right_motor (void); |
jah128 | 4:52b3e4c5a425 | 177 | |
jah128 | 4:52b3e4c5a425 | 178 | // Directly control the speed and direction of the left motor (range -1.0 to 1.0) |
jah128 | 4:52b3e4c5a425 | 179 | void left_motor (float speed); |
jah128 | 4:52b3e4c5a425 | 180 | |
jah128 | 4:52b3e4c5a425 | 181 | // Directly control the speed and direction of the right motor (range -1.0 to 1.0) |
jah128 | 4:52b3e4c5a425 | 182 | void right_motor (float speed); |
jah128 | 4:52b3e4c5a425 | 183 | |
jah128 | 4:52b3e4c5a425 | 184 | // Drive both motors forward as the same speed (range -1.0 to 1.0) |
jah128 | 4:52b3e4c5a425 | 185 | void forward (float speed); |
jah128 | 4:52b3e4c5a425 | 186 | |
jah128 | 4:52b3e4c5a425 | 187 | // Drive both motors backward as the same speed (range -1.0 to 1.0) |
jah128 | 4:52b3e4c5a425 | 188 | void backward (float speed); |
jah128 | 4:52b3e4c5a425 | 189 | |
jah128 | 4:52b3e4c5a425 | 190 | // 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 | 191 | void left (float speed); |
jah128 | 4:52b3e4c5a425 | 192 | |
jah128 | 4:52b3e4c5a425 | 193 | // 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 | 194 | void right (float speed); |
jah128 | 4:52b3e4c5a425 | 195 | |
jah128 | 4:52b3e4c5a425 | 196 | // Stop both motors |
jah128 | 4:52b3e4c5a425 | 197 | void stop (void); |
jah128 | 0:9ffe8ebd1c40 | 198 | |
jah128 | 4:52b3e4c5a425 | 199 | // Play a tune on the 3-pi buzzer (see notes at end of file for more details) |
jah128 | 4:52b3e4c5a425 | 200 | void play_tune (char * tune, int length); |
jah128 | 4:52b3e4c5a425 | 201 | |
jah128 | 4:52b3e4c5a425 | 202 | ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// |
jah128 | 4:52b3e4c5a425 | 203 | // EEPROM Functions |
jah128 | 4:52b3e4c5a425 | 204 | ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// |
jah128 | 4:52b3e4c5a425 | 205 | |
jah128 | 0:9ffe8ebd1c40 | 206 | // Write single byte to EEPROM |
jah128 | 0:9ffe8ebd1c40 | 207 | void write_eeprom_byte ( int address, char data ); |
jah128 | 0:9ffe8ebd1c40 | 208 | |
jah128 | 0:9ffe8ebd1c40 | 209 | // Write (length) bytes to EEPROM |
jah128 | 0:9ffe8ebd1c40 | 210 | void write_eeprom_block ( int address, char length, char * data); |
jah128 | 0:9ffe8ebd1c40 | 211 | |
jah128 | 0:9ffe8ebd1c40 | 212 | // Read single byte from EEPROM |
jah128 | 0:9ffe8ebd1c40 | 213 | char read_eeprom_byte ( int address ); |
jah128 | 0:9ffe8ebd1c40 | 214 | |
jah128 | 0:9ffe8ebd1c40 | 215 | // Read next byte from EEPROM at current address |
jah128 | 0:9ffe8ebd1c40 | 216 | char read_next_eeprom_byte ( void ); |
jah128 | 0:9ffe8ebd1c40 | 217 | |
jah128 | 0:9ffe8ebd1c40 | 218 | // Read (length) from EEPROM |
jah128 | 0:9ffe8ebd1c40 | 219 | char read_eeprom_block ( int address, char length ); |
jah128 | 4:52b3e4c5a425 | 220 | |
jah128 | 4:52b3e4c5a425 | 221 | ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// |
jah128 | 4:52b3e4c5a425 | 222 | // Display Functions |
jah128 | 4:52b3e4c5a425 | 223 | ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// |
jah128 | 4:52b3e4c5a425 | 224 | |
jah128 | 4:52b3e4c5a425 | 225 | // Locate the cursor on the 8x2 LCD [to position x (0-7), y (0-1)] |
jah128 | 4:52b3e4c5a425 | 226 | void locate(int x, int y); |
jah128 | 0:9ffe8ebd1c40 | 227 | |
jah128 | 4:52b3e4c5a425 | 228 | // Clear the LCD |
jah128 | 4:52b3e4c5a425 | 229 | void cls(void); |
jah128 | 4:52b3e4c5a425 | 230 | |
jah128 | 4:52b3e4c5a425 | 231 | ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// |
jah128 | 4:52b3e4c5a425 | 232 | // Setup and Internal Functions |
jah128 | 4:52b3e4c5a425 | 233 | // Generally these functions should not be called by user code |
jah128 | 4:52b3e4c5a425 | 234 | ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// |
jah128 | 4:52b3e4c5a425 | 235 | |
jah128 | 4:52b3e4c5a425 | 236 | // Send a message of given length over the RF interface |
jah128 | 4:52b3e4c5a425 | 237 | void send_rf_message(char* message, char length); |
jah128 | 4:52b3e4c5a425 | 238 | |
jah128 | 4:52b3e4c5a425 | 239 | // The default setup routine: called when the Pi Swarm is created |
jah128 | 4:52b3e4c5a425 | 240 | void setup ( void ); |
jah128 | 4:52b3e4c5a425 | 241 | |
jah128 | 4:52b3e4c5a425 | 242 | // Sets up the IO expansion IC using I2C commands; returns a zero if successful |
jah128 | 4:52b3e4c5a425 | 243 | int setup_expansion_ic ( void ); |
jah128 | 4:52b3e4c5a425 | 244 | |
jah128 | 4:52b3e4c5a425 | 245 | // Called after a delay from the IO expansion interrupt; delay helps debounce switches |
jah128 | 4:52b3e4c5a425 | 246 | void interrupt_timeout_event ( void ); |
jah128 | 0:9ffe8ebd1c40 | 247 | |
jah128 | 4:52b3e4c5a425 | 248 | // The interrupt handler for the IO expansion IC; calls the timeout event to debounce switches |
jah128 | 4:52b3e4c5a425 | 249 | void expansion_interrupt_handler ( void ); |
jah128 | 4:52b3e4c5a425 | 250 | |
jah128 | 4:52b3e4c5a425 | 251 | // Turns off interrupt LED after a delay to indicate switch has been pressed |
jah128 | 4:52b3e4c5a425 | 252 | void led_timeout_event ( void ); |
jah128 | 4:52b3e4c5a425 | 253 | |
jah128 | 4:52b3e4c5a425 | 254 | // 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 | 255 | char calibrate_gyro ( void ); |
jah128 | 4:52b3e4c5a425 | 256 | |
jah128 | 4:52b3e4c5a425 | 257 | // 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 | 258 | char calibrate_accelerometer ( void ); |
jah128 | 0:9ffe8ebd1c40 | 259 | |
jah128 | 4:52b3e4c5a425 | 260 | // Routine to calibrate magnetometer (Returns 1 if successful, 0 if failed) |
jah128 | 4:52b3e4c5a425 | 261 | char calibrate_magnetometer ( void ); |
jah128 | 4:52b3e4c5a425 | 262 | |
jah128 | 4:52b3e4c5a425 | 263 | // Send instructions to the I2C ADC (for IR measurement) |
jah128 | 4:52b3e4c5a425 | 264 | char setup_adc( void ); |
jah128 | 4:52b3e4c5a425 | 265 | |
jah128 | 4:52b3e4c5a425 | 266 | // Routine to initialise radio |
jah128 | 4:52b3e4c5a425 | 267 | void setup_radio( void ); |
jah128 | 4:52b3e4c5a425 | 268 | |
jah128 | 4:52b3e4c5a425 | 269 | // Blinks the calibration LED during calibration (turns off if calibration successful) |
jah128 | 4:52b3e4c5a425 | 270 | void calibrate_ticker_routine ( void ); |
jah128 | 0:9ffe8ebd1c40 | 271 | |
jah128 | 4:52b3e4c5a425 | 272 | // Used to debug/test the OLED array |
jah128 | 4:52b3e4c5a425 | 273 | void test_oled(void); |
jah128 | 4:52b3e4c5a425 | 274 | |
jah128 | 4:52b3e4c5a425 | 275 | // Starts the system timer |
jah128 | 4:52b3e4c5a425 | 276 | void start_system_timer(void); |
jah128 | 4:52b3e4c5a425 | 277 | |
jah128 | 4:52b3e4c5a425 | 278 | ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// |
jah128 | 4:52b3e4c5a425 | 279 | // Native m3Pi Functions |
jah128 | 4:52b3e4c5a425 | 280 | // These should preserve functionality of (most) m3pi code but may be fully functional on Pi Swarm |
jah128 | 4:52b3e4c5a425 | 281 | ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// |
jah128 | 4:52b3e4c5a425 | 282 | |
jah128 | 1:b067a08ff54e | 283 | // Force a hardware reset of the 3-pi |
jah128 | 0:9ffe8ebd1c40 | 284 | void reset (void); |
jah128 | 0:9ffe8ebd1c40 | 285 | |
jah128 | 4:52b3e4c5a425 | 286 | // Read the position of the detected line [using line-following IR] |
jah128 | 0:9ffe8ebd1c40 | 287 | float line_position (void); |
jah128 | 0:9ffe8ebd1c40 | 288 | |
jah128 | 4:52b3e4c5a425 | 289 | // Calibrate the sensors. This turns the robot left then right, looking for a line [using line-following IR] |
jah128 | 0:9ffe8ebd1c40 | 290 | char sensor_auto_calibrate (void); |
jah128 | 0:9ffe8ebd1c40 | 291 | |
jah128 | 4:52b3e4c5a425 | 292 | // Set calibration manually to the current settings. |
jah128 | 0:9ffe8ebd1c40 | 293 | void calibrate(void); |
jah128 | 0:9ffe8ebd1c40 | 294 | |
jah128 | 4:52b3e4c5a425 | 295 | // Clear the current calibration settings |
jah128 | 0:9ffe8ebd1c40 | 296 | void reset_calibration (void); |
jah128 | 0:9ffe8ebd1c40 | 297 | |
jah128 | 4:52b3e4c5a425 | 298 | // Start the PID contoller |
jah128 | 0:9ffe8ebd1c40 | 299 | void PID_start(int max_speed, int a, int b, int c, int d); |
jah128 | 0:9ffe8ebd1c40 | 300 | |
jah128 | 4:52b3e4c5a425 | 301 | // Stop the PID controller |
jah128 | 0:9ffe8ebd1c40 | 302 | void PID_stop(); |
jah128 | 0:9ffe8ebd1c40 | 303 | |
jah128 | 4:52b3e4c5a425 | 304 | // Send a character directly to the 3pi serial interface |
jah128 | 0:9ffe8ebd1c40 | 305 | int putc(int c); |
jah128 | 0:9ffe8ebd1c40 | 306 | |
jah128 | 4:52b3e4c5a425 | 307 | // Receive a character directly to the 3pi serial interface |
jah128 | 0:9ffe8ebd1c40 | 308 | int getc(); |
jah128 | 0:9ffe8ebd1c40 | 309 | |
jah128 | 4:52b3e4c5a425 | 310 | // Send a string buffer to the 3pi serial interface |
jah128 | 0:9ffe8ebd1c40 | 311 | int print(char* text, int length); |
jah128 | 0:9ffe8ebd1c40 | 312 | |
jah128 | 4:52b3e4c5a425 | 313 | #ifdef MBED_RPC |
jah128 | 4:52b3e4c5a425 | 314 | virtual const struct rpc_method *get_rpc_methods(); |
jah128 | 4:52b3e4c5a425 | 315 | #endif |
jah128 | 0:9ffe8ebd1c40 | 316 | |
jah128 | 4:52b3e4c5a425 | 317 | private : |
jah128 | 0:9ffe8ebd1c40 | 318 | |
jah128 | 0:9ffe8ebd1c40 | 319 | Serial _ser; |
jah128 | 0:9ffe8ebd1c40 | 320 | PwmOut _oled_r, _oled_g, _oled_b, _cled_r, _cled_g, _cled_b; |
jah128 | 0:9ffe8ebd1c40 | 321 | AnalogIn _gyro, _accel_x, _accel_y, _accel_z, _temperature, _light; |
jah128 | 4:52b3e4c5a425 | 322 | I2C _i2c; |
jah128 | 0:9ffe8ebd1c40 | 323 | DigitalOut _irpulse_1, _irpulse_2; |
jah128 | 0:9ffe8ebd1c40 | 324 | Alpha433 _rf; |
jah128 | 0:9ffe8ebd1c40 | 325 | Timer _system_timer; |
jah128 | 0:9ffe8ebd1c40 | 326 | |
jah128 | 0:9ffe8ebd1c40 | 327 | void motor (int motor, float speed); |
jah128 | 0:9ffe8ebd1c40 | 328 | virtual int _putc(int c); |
jah128 | 0:9ffe8ebd1c40 | 329 | virtual int _getc(); |
jah128 | 0:9ffe8ebd1c40 | 330 | |
jah128 | 0:9ffe8ebd1c40 | 331 | }; |
jah128 | 0:9ffe8ebd1c40 | 332 | |
jah128 | 0:9ffe8ebd1c40 | 333 | void display_system_time(void); |
jah128 | 0:9ffe8ebd1c40 | 334 | void init(void); |
jah128 | 0:9ffe8ebd1c40 | 335 | extern Serial pc; |
jah128 | 0:9ffe8ebd1c40 | 336 | extern PiSwarm piswarm; |
jah128 | 0:9ffe8ebd1c40 | 337 | |
jah128 | 0:9ffe8ebd1c40 | 338 | #endif |
jah128 | 0:9ffe8ebd1c40 | 339 | |
jah128 | 1:b067a08ff54e | 340 | /******************************************************************************** |
jah128 | 1:b067a08ff54e | 341 | * MBED Pin connection layout * |
jah128 | 1:b067a08ff54e | 342 | * * |
jah128 | 1:b067a08ff54e | 343 | * * Pin 05 : Alpha Transceiver SDI * |
jah128 | 1:b067a08ff54e | 344 | * * Pin 06 : Alpha Transceiver SDO * |
jah128 | 1:b067a08ff54e | 345 | * * Pin 07 : Alpha Transceiver CLK * |
jah128 | 1:b067a08ff54e | 346 | * * Pin 08 : Alpha Transceiver FSS * |
jah128 | 1:b067a08ff54e | 347 | * * Pin 09 : Serial (3pi) transmit * |
jah128 | 1:b067a08ff54e | 348 | * * Pin 10 : Serial (3pi) receive * |
jah128 | 1:b067a08ff54e | 349 | * * Pin 11 : Alpha Transceiver NIRQ * |
jah128 | 1:b067a08ff54e | 350 | * * Pin 12 : IR Pulse Output for IR1,2,7,8 * |
jah128 | 1:b067a08ff54e | 351 | * * Pin 13 : IR Pulse Output for IR3,4,5,6 * |
jah128 | 1:b067a08ff54e | 352 | * * Pin 14 : Echo Pin for Sonar * |
jah128 | 1:b067a08ff54e | 353 | * * Pin 15 : Light Sensor Analogue Input * |
jah128 | 1:b067a08ff54e | 354 | * * Pin 16 : Gyrometer Analogue Input * |
jah128 | 1:b067a08ff54e | 355 | * * Pin 17 : Accelerometer Z Analogue Input * |
jah128 | 1:b067a08ff54e | 356 | * * Pin 18 : Accelerometer Y Analogue Input * |
jah128 | 1:b067a08ff54e | 357 | * * Pin 19 : Accelerometer X Analogue Input * |
jah128 | 1:b067a08ff54e | 358 | * * Pin 20 : Temperature Sensor Analogue Input * |
jah128 | 1:b067a08ff54e | 359 | * * Pin 21 : Center LED Blue PWM Output * |
jah128 | 1:b067a08ff54e | 360 | * * Pin 22 : Center LED Green PWM Output * |
jah128 | 1:b067a08ff54e | 361 | * * Pin 23 : Center LED Red PWM Output * |
jah128 | 1:b067a08ff54e | 362 | * * Pin 24 : Outer LED Blue PWM Output * |
jah128 | 1:b067a08ff54e | 363 | * * Pin 25 : Outer LED Green PWM Output * |
jah128 | 1:b067a08ff54e | 364 | * * Pin 26 : Outer LED Red PWM Output * |
jah128 | 1:b067a08ff54e | 365 | * * Pin 27 : I2C SCL * |
jah128 | 1:b067a08ff54e | 366 | * * Pin 28 : I2C SDA * |
jah128 | 1:b067a08ff54e | 367 | * * Pin 29 : GPIO Expander Interrupt * |
jah128 | 1:b067a08ff54e | 368 | * * Pin 30 : Trigger Pin for Sonar * |
jah128 | 1:b067a08ff54e | 369 | * * Pin 31 : USB D+ Connector * |
jah128 | 1:b067a08ff54e | 370 | * * Pin 32 : USB D- Connector * |
jah128 | 1:b067a08ff54e | 371 | * * |
jah128 | 1:b067a08ff54e | 372 | *******************************************************************************/ |
jah128 | 0:9ffe8ebd1c40 | 373 | |
jah128 | 0:9ffe8ebd1c40 | 374 | /******************************************************************************** |
jah128 | 1:b067a08ff54e | 375 | * Using the 3-Pi Buzzer * |
jah128 | 1:b067a08ff54e | 376 | * * |
jah128 | 1:b067a08ff54e | 377 | * play_tune (char * tune, int length) * |
jah128 | 1:b067a08ff54e | 378 | * * |
jah128 | 1:b067a08ff54e | 379 | * tune - Pointer to a character sequence of the tune * |
jah128 | 1:b067a08ff54e | 380 | * length - Length of characters in sequence * |
jah128 | 1:b067a08ff54e | 381 | * * |
jah128 | 1:b067a08ff54e | 382 | * The character sequence recognises the following characters: * |
jah128 | 1:b067a08ff54e | 383 | * * |
jah128 | 1:b067a08ff54e | 384 | * A – G : used to specify the notes that will be played * |
jah128 | 1:b067a08ff54e | 385 | * * |
jah128 | 1:b067a08ff54e | 386 | * R : used to specify a rest (no sound for the duration of the note) * |
jah128 | 1:b067a08ff54e | 387 | * * |
jah128 | 1:b067a08ff54e | 388 | * < or > : plays the next note one octave lower or higher * |
jah128 | 1:b067a08ff54e | 389 | * * |
jah128 | 1:b067a08ff54e | 390 | * + or # : raises the previous notes pitch by one semitone * |
jah128 | 1:b067a08ff54e | 391 | * * |
jah128 | 1:b067a08ff54e | 392 | * - : lowers the previous note pitch by one semitone * |
jah128 | 1:b067a08ff54e | 393 | * * |
jah128 | 1:b067a08ff54e | 394 | * . : extend length of previous by 50% (each additional dot adds half as * |
jah128 | 1:b067a08ff54e | 395 | * much as the previous dot, so that A.. is 1.75 times the length of A * |
jah128 | 1:b067a08ff54e | 396 | * * |
jah128 | 1:b067a08ff54e | 397 | * O followed by a number : sets the octave (default : O4) * |
jah128 | 1:b067a08ff54e | 398 | * * |
jah128 | 1:b067a08ff54e | 399 | * T followed by a number : sets the tempo in beats/min (default : T120) * |
jah128 | 1:b067a08ff54e | 400 | * * |
jah128 | 1:b067a08ff54e | 401 | * L followed by a number : sets the default note duration specified by the* |
jah128 | 1:b067a08ff54e | 402 | * number - 4 for quarter notes, 8 for eighth, 16 * |
jah128 | 1:b067a08ff54e | 403 | * for sixteenth notes, etc. (default : L4) * |
jah128 | 1:b067a08ff54e | 404 | * * |
jah128 | 1:b067a08ff54e | 405 | * V followed by a number : sets the volume (range 0 - 15, default : V15) * |
jah128 | 1:b067a08ff54e | 406 | * * |
jah128 | 1:b067a08ff54e | 407 | * MS : sets all subsequent notes to play staccato (each note is played for* |
jah128 | 1:b067a08ff54e | 408 | * 1/2 of its allotted time followed by an equal period of silence) * |
jah128 | 1:b067a08ff54e | 409 | * * |
jah128 | 1:b067a08ff54e | 410 | * ML : sets all subsequent notes to play legato (each note is played for * |
jah128 | 1:b067a08ff54e | 411 | * full length. This is the default setting. * |
jah128 | 1:b067a08ff54e | 412 | * * |
jah128 | 1:b067a08ff54e | 413 | * ! : resets the octave, tempo, duration, volume, and staccato setting to * |
jah128 | 1:b067a08ff54e | 414 | * their default values. These settings persist from one play_tune() to* |
jah128 | 1:b067a08ff54e | 415 | * the next, which allows you to more conveniently break up your music * |
jah128 | 1:b067a08ff54e | 416 | * into reusable sections. * |
jah128 | 1:b067a08ff54e | 417 | * * |
jah128 | 1:b067a08ff54e | 418 | * 1 - 2000 : when immediately following a note, a number determines the * |
jah128 | 1:b067a08ff54e | 419 | * duration of the note. For example, C16 specifies C played as * |
jah128 | 1:b067a08ff54e | 420 | * a sixteenth note (1/16th the length of a whole note). * |
jah128 | 1:b067a08ff54e | 421 | * * |
jah128 | 1:b067a08ff54e | 422 | * * |
jah128 | 1:b067a08ff54e | 423 | * Some examples: * |
jah128 | 1:b067a08ff54e | 424 | * * |
jah128 | 1:b067a08ff54e | 425 | * Blue Danube Waltz (played badly!) * |
jah128 | 1:b067a08ff54e | 426 | * play_tune("MSCEGGR>F>FR>D>DRCCEGGR>G>GR>E>ER<B<BDAAR>A>AR>F>F",51); * |
jah128 | 1:b067a08ff54e | 427 | * * |
jah128 | 1:b067a08ff54e | 428 | *******************************************************************************/ |
jah128 | 1:b067a08ff54e | 429 | |
jah128 | 1:b067a08ff54e | 430 | /******************************************************************************** |
jah128 | 0:9ffe8ebd1c40 | 431 | * COPYRIGHT NOTICE * |
jah128 | 0:9ffe8ebd1c40 | 432 | * * |
jah128 | 4:52b3e4c5a425 | 433 | * * |
jah128 | 4:52b3e4c5a425 | 434 | * Parts of code based on the original m3pi library, Copyright (c) 2010 cstyles * |
jah128 | 4:52b3e4c5a425 | 435 | * * |
jah128 | 0:9ffe8ebd1c40 | 436 | * Permission is hereby granted, free of charge, to any person obtaining a copy * |
jah128 | 0:9ffe8ebd1c40 | 437 | * of this software and associated documentation files (the "Software"), to deal* |
jah128 | 0:9ffe8ebd1c40 | 438 | * in the Software without restriction, including without limitation the rights * |
jah128 | 0:9ffe8ebd1c40 | 439 | * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell * |
jah128 | 0:9ffe8ebd1c40 | 440 | * copies of the Software, and to permit persons to whom the Software is * |
jah128 | 0:9ffe8ebd1c40 | 441 | * furnished to do so, subject to the following conditions: * |
jah128 | 0:9ffe8ebd1c40 | 442 | * * |
jah128 | 0:9ffe8ebd1c40 | 443 | * The above copyright notice and this permission notice shall be included in * |
jah128 | 0:9ffe8ebd1c40 | 444 | * all copies or substantial portions of the Software. * |
jah128 | 0:9ffe8ebd1c40 | 445 | * * |
jah128 | 0:9ffe8ebd1c40 | 446 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * |
jah128 | 0:9ffe8ebd1c40 | 447 | * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * |
jah128 | 0:9ffe8ebd1c40 | 448 | * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE * |
jah128 | 0:9ffe8ebd1c40 | 449 | * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * |
jah128 | 0:9ffe8ebd1c40 | 450 | * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,* |
jah128 | 0:9ffe8ebd1c40 | 451 | * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN * |
jah128 | 0:9ffe8ebd1c40 | 452 | * THE SOFTWARE. * |
jah128 | 0:9ffe8ebd1c40 | 453 | * * |
jah128 | 0:9ffe8ebd1c40 | 454 | *******************************************************************************/ |