Psi Swarm Robot / PsiSwarmV9

Psi Swarm robot library version 0.9

Dependents:   PsiSwarm_V9_Blank

Fork of PsiSwarmV9 by James Hilder

eprom.cpp@18:9204f74069b4, 2017-06-04 (annotated)

Committer:
jah128
Date:
Sun Jun 04 20:22:41 2017 +0000
Revision:
18:9204f74069b4
Parent:
17:bf614e28668f
Child:
19:3e3b03d80ea3
Updated self-test

Who changed what in which revision?

UserRevisionLine numberNew contents of line
jah128 0:d6269d17c8cf 1 /** University of York Robotics Laboratory PsiSwarm Library: Eprom Functions Source File
jah128 8:6c92789d5f87 2 *
jah128 14:2f1ad77d281e 3 * Copyright 2017 University of York
jah128 6:b340a527add9 4 *
jah128 8:6c92789d5f87 5 * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License.
jah128 6:b340a527add9 6 * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
jah128 6:b340a527add9 7 * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS
jah128 8:6c92789d5f87 8 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
jah128 6:b340a527add9 9 * See the License for the specific language governing permissions and limitations under the License.
jah128 0:d6269d17c8cf 10 *
jah128 0:d6269d17c8cf 11 * File: eprom.cpp
jah128 0:d6269d17c8cf 12 *
jah128 0:d6269d17c8cf 13 * (C) Dept. Electronics & Computer Science, University of York
jah128 0:d6269d17c8cf 14 * James Hilder, Alan Millard, Alexander Horsfield, Homero Elizondo, Jon Timmis
jah128 0:d6269d17c8cf 15 *
jah128 14:2f1ad77d281e 16 * PsiSwarm Library Version: 0.9
jah128 0:d6269d17c8cf 17 *
jah128 14:2f1ad77d281e 18 * June 2017
jah128 0:d6269d17c8cf 19 *
jah128 0:d6269d17c8cf 20 * Functions for accessing the 64Kb EPROM chip and reading the reserved firmware block
jah128 0:d6269d17c8cf 21 *
jah128 0:d6269d17c8cf 22 * Example:
jah128 0:d6269d17c8cf 23 * @code
jah128 0:d6269d17c8cf 24 * #include "psiswarm.h"
jah128 0:d6269d17c8cf 25 *
jah128 0:d6269d17c8cf 26 * int main() {
jah128 0:d6269d17c8cf 27 * init();
jah128 8:6c92789d5f87 28 * eprom.write_eeprom_byte(0,0xDD); //Writes byte 0xDD in EPROM address 0
jah128 8:6c92789d5f87 29 * char c = eprom.read_eeprom_byte(0); //c will hold 0xDD
jah128 0:d6269d17c8cf 30 * //Valid address range is from 0 to 65279
jah128 0:d6269d17c8cf 31 * }
jah128 0:d6269d17c8cf 32 * @endcode
jah128 0:d6269d17c8cf 33 */
jah128 0:d6269d17c8cf 34
jah128 0:d6269d17c8cf 35 #include "psiswarm.h"
jah128 0:d6269d17c8cf 36
jah128 0:d6269d17c8cf 37 /** Write a single byte to the EPROM
jah128 0:d6269d17c8cf 38 *
jah128 0:d6269d17c8cf 39 * @param address The address to store the data, range 0-65279
jah128 0:d6269d17c8cf 40 * @param data The character to store
jah128 0:d6269d17c8cf 41 */
jah128 8:6c92789d5f87 42 void Eprom::write_eeprom_byte ( int address, char data )
jah128 0:d6269d17c8cf 43 {
jah128 0:d6269d17c8cf 44 char write_array[3];
jah128 0:d6269d17c8cf 45 if(address > 65279) {
jah128 12:878c6e9d9e60 46 psi.debug("WARNING: Attempt to write to invalid EPROM address: %X",address);
jah128 0:d6269d17c8cf 47 } else {
jah128 0:d6269d17c8cf 48 write_array[0] = address / 256;
jah128 0:d6269d17c8cf 49 write_array[1] = address % 256;
jah128 0:d6269d17c8cf 50 write_array[2] = data;
jah128 0:d6269d17c8cf 51 primary_i2c.write(EEPROM_ADDRESS, write_array, 3, false);
jah128 0:d6269d17c8cf 52 //Takes 5ms to write a page: ideally this could be done with a timer or RTOS
jah128 0:d6269d17c8cf 53 wait(0.005);
jah128 0:d6269d17c8cf 54 }
jah128 0:d6269d17c8cf 55 }
jah128 0:d6269d17c8cf 56
jah128 0:d6269d17c8cf 57 /** Read a single byte from the EPROM
jah128 0:d6269d17c8cf 58 *
jah128 0:d6269d17c8cf 59 * @param address The address to read from, range 0-65279
jah128 0:d6269d17c8cf 60 * @return The character stored at address
jah128 0:d6269d17c8cf 61 */
jah128 8:6c92789d5f87 62 char Eprom::read_eeprom_byte ( int address )
jah128 0:d6269d17c8cf 63 {
jah128 0:d6269d17c8cf 64 char address_array [2];
jah128 0:d6269d17c8cf 65 address_array[0] = address / 256;
jah128 0:d6269d17c8cf 66 address_array[1] = address % 256;
jah128 0:d6269d17c8cf 67 char data [1];
jah128 0:d6269d17c8cf 68 primary_i2c.write(EEPROM_ADDRESS, address_array, 2, false);
jah128 0:d6269d17c8cf 69 primary_i2c.read(EEPROM_ADDRESS, data, 1, false);
jah128 0:d6269d17c8cf 70 return data [0];
jah128 0:d6269d17c8cf 71 }
jah128 0:d6269d17c8cf 72
jah128 0:d6269d17c8cf 73 /** Read the next byte from the EPROM, to be called after read_eeprom_byte
jah128 0:d6269d17c8cf 74 *
jah128 0:d6269d17c8cf 75 * @return The character stored at address after the previous one read from
jah128 0:d6269d17c8cf 76 */
jah128 8:6c92789d5f87 77 char Eprom::read_next_eeprom_byte ()
jah128 0:d6269d17c8cf 78 {
jah128 0:d6269d17c8cf 79 char data [1];
jah128 0:d6269d17c8cf 80 primary_i2c.read(EEPROM_ADDRESS, data, 1, false);
jah128 0:d6269d17c8cf 81 return data [0];
jah128 0:d6269d17c8cf 82 }
jah128 0:d6269d17c8cf 83
jah128 17:bf614e28668f 84 void Eprom::write_firmware_byte ( int address, char data ){
jah128 17:bf614e28668f 85 char write_array[3];
jah128 17:bf614e28668f 86 write_array[0] = 255;
jah128 17:bf614e28668f 87 write_array[1] = address % 256;
jah128 17:bf614e28668f 88 write_array[2] = data;
jah128 17:bf614e28668f 89 primary_i2c.write(EEPROM_ADDRESS, write_array, 3, false);
jah128 17:bf614e28668f 90 //Takes 5ms to write a page: ideally this could be done with a timer or RTOS
jah128 17:bf614e28668f 91 wait(0.005);
jah128 17:bf614e28668f 92 }
jah128 17:bf614e28668f 93
jah128 17:bf614e28668f 94
jah128 17:bf614e28668f 95 char Eprom::read_firmware_byte ( int address ){
jah128 17:bf614e28668f 96 char address_array [2];
jah128 17:bf614e28668f 97 address_array[0] = 255;
jah128 17:bf614e28668f 98 address_array[1] = address % 256;
jah128 17:bf614e28668f 99 char data [1];
jah128 17:bf614e28668f 100 primary_i2c.write(EEPROM_ADDRESS, address_array, 2, false);
jah128 17:bf614e28668f 101 primary_i2c.read(EEPROM_ADDRESS, data, 1, false);
jah128 17:bf614e28668f 102 return data [0];
jah128 17:bf614e28668f 103 }
jah128 17:bf614e28668f 104
jah128 0:d6269d17c8cf 105 /** Read the data stored in the reserved firmware area of the EPROM
jah128 0:d6269d17c8cf 106 *
jah128 0:d6269d17c8cf 107 * @return 1 if a valid firmware is read, 0 otherwise
jah128 0:d6269d17c8cf 108 */
jah128 8:6c92789d5f87 109 char Eprom::read_firmware ()
jah128 0:d6269d17c8cf 110 {
jah128 0:d6269d17c8cf 111 char address_array [2] = {255,0};
jah128 0:d6269d17c8cf 112 primary_i2c.write(EEPROM_ADDRESS, address_array, 2, false);
jah128 17:bf614e28668f 113 primary_i2c.read(EEPROM_ADDRESS, firmware_bytes, 80, false);
jah128 18:9204f74069b4 114 left_motor_stall_offset = LEFT_STALL * 0.01f;
jah128 18:9204f74069b4 115 right_motor_stall_offset = RIGHT_STALL * 0.01f;
jah128 0:d6269d17c8cf 116 if(firmware_bytes[0] == PSI_BYTE) {
jah128 0:d6269d17c8cf 117 // Parse firmware
jah128 0:d6269d17c8cf 118 char firmware_string [8];
jah128 0:d6269d17c8cf 119 sprintf(firmware_string,"%d.%d",firmware_bytes[9],firmware_bytes[10]);
jah128 0:d6269d17c8cf 120 firmware_version = atof(firmware_string);
jah128 1:060690a934a9 121 char pcb_version_string [8];
jah128 1:060690a934a9 122 sprintf(pcb_version_string,"%d.%d",firmware_bytes[7],firmware_bytes[8]);
jah128 1:060690a934a9 123 pcb_version = atof(pcb_version_string);
jah128 1:060690a934a9 124 char serial_number_string [8];
jah128 17:bf614e28668f 125 if(firmware_bytes[6] > 9) sprintf(serial_number_string,"%d.%d",firmware_bytes[5],firmware_bytes[6]);
jah128 17:bf614e28668f 126 else sprintf(serial_number_string,"%d.0%d",firmware_bytes[5],firmware_bytes[6]);
jah128 1:060690a934a9 127 serial_number = atof(serial_number_string);
jah128 1:060690a934a9 128 has_compass = firmware_bytes[11];
jah128 1:060690a934a9 129 has_side_ir = firmware_bytes[12];
jah128 1:060690a934a9 130 has_base_ir = firmware_bytes[13];
jah128 1:060690a934a9 131 has_base_colour_sensor= firmware_bytes[14];
jah128 1:060690a934a9 132 has_top_colour_sensor= firmware_bytes[15];
jah128 1:060690a934a9 133 has_wheel_encoders= firmware_bytes[16];
jah128 1:060690a934a9 134 has_audio_pic= firmware_bytes[17];
jah128 1:060690a934a9 135 has_ultrasonic_sensor= firmware_bytes[18];
jah128 1:060690a934a9 136 has_temperature_sensor= firmware_bytes[19];
jah128 1:060690a934a9 137 has_recharging_circuit= firmware_bytes[20];
jah128 1:060690a934a9 138 has_433_radio= firmware_bytes[21];
jah128 8:6c92789d5f87 139 if(firmware_version > 1.0) {
jah128 8:6c92789d5f87 140 motor_calibration_set = firmware_bytes[22];
jah128 8:6c92789d5f87 141 if(motor_calibration_set == 1) {
jah128 8:6c92789d5f87 142 left_motor_calibration_value = (float) firmware_bytes[23] * 65536;
jah128 8:6c92789d5f87 143 left_motor_calibration_value += ((float) firmware_bytes[24] * 256);
jah128 8:6c92789d5f87 144 left_motor_calibration_value += firmware_bytes[25];
jah128 8:6c92789d5f87 145 left_motor_calibration_value /= 16777216;
jah128 8:6c92789d5f87 146 right_motor_calibration_value = (float) firmware_bytes[26] * 65536;
jah128 8:6c92789d5f87 147 right_motor_calibration_value += ((float) firmware_bytes[27] * 256);
jah128 8:6c92789d5f87 148 right_motor_calibration_value += firmware_bytes[28];
jah128 8:6c92789d5f87 149 right_motor_calibration_value /= 16777216;
jah128 17:bf614e28668f 150 } else motor_calibration_set = 0;
jah128 4:1c621cb8cf0d 151 } else motor_calibration_set = 0;
jah128 17:bf614e28668f 152 if(firmware_version > 1.1) {
jah128 18:9204f74069b4 153 boot_count = firmware_bytes[69] << 8;
jah128 18:9204f74069b4 154 boot_count += firmware_bytes[70];
jah128 18:9204f74069b4 155 boot_count++;
jah128 18:9204f74069b4 156 eprom.write_firmware_byte(69,(char)(boot_count >> 8));
jah128 18:9204f74069b4 157 eprom.write_firmware_byte(70,(char)(boot_count % 256));
jah128 18:9204f74069b4 158 if(motor_calibration_set == 1) {
jah128 18:9204f74069b4 159 left_motor_stall_offset = (((float) (firmware_bytes[67])) * 0.01f);
jah128 18:9204f74069b4 160 right_motor_stall_offset = (((float) (firmware_bytes[68])) * 0.01f);
jah128 18:9204f74069b4 161 }
jah128 17:bf614e28668f 162 base_ir_calibration_set = firmware_bytes[29];
jah128 17:bf614e28668f 163 if(base_ir_calibration_set == 1){
jah128 17:bf614e28668f 164 int white_values[5];
jah128 17:bf614e28668f 165 int black_values[5];
jah128 17:bf614e28668f 166 for(int i=0;i<5;i++){
jah128 17:bf614e28668f 167 int k_val = i+i;
jah128 17:bf614e28668f 168 white_values[i] = (firmware_bytes[30 + k_val] << 8) + firmware_bytes[31 + k_val];
jah128 17:bf614e28668f 169 black_values[i] = (firmware_bytes[40 + k_val] << 8) + firmware_bytes[41 + k_val];
jah128 17:bf614e28668f 170 }
jah128 17:bf614e28668f 171 sensors.IF_set_base_calibration_values(white_values[0], white_values[1], white_values[2], white_values[3], white_values[4], black_values[0], black_values[1], black_values[2], black_values[3], black_values[4]);
jah128 17:bf614e28668f 172 }else base_ir_calibration_set = 0;
jah128 17:bf614e28668f 173 base_colour_calibration_set = firmware_bytes[50];
jah128 17:bf614e28668f 174 if(base_colour_calibration_set == 1){
jah128 17:bf614e28668f 175 int white_values[4];
jah128 17:bf614e28668f 176 int black_values[4];
jah128 17:bf614e28668f 177 for(int i=0;i<4;i++){
jah128 17:bf614e28668f 178 int k_val = i+i;
jah128 17:bf614e28668f 179 white_values[i] = (firmware_bytes[51 + k_val] << 8) + firmware_bytes[52 + k_val];
jah128 17:bf614e28668f 180 black_values[i] = (firmware_bytes[59 + k_val] << 8) + firmware_bytes[60 + k_val];
jah128 17:bf614e28668f 181 }
jah128 17:bf614e28668f 182 colour.set_calibration_values(black_values[0],black_values[1],black_values[2],black_values[3],white_values[0],white_values[1],white_values[2],white_values[3]);
jah128 17:bf614e28668f 183 }else base_colour_calibration_set = 0;
jah128 17:bf614e28668f 184 } else {
jah128 17:bf614e28668f 185 base_ir_calibration_set = 0;
jah128 17:bf614e28668f 186 base_colour_calibration_set = 0;
jah128 17:bf614e28668f 187 }
jah128 0:d6269d17c8cf 188 return 1;
jah128 0:d6269d17c8cf 189 }
jah128 0:d6269d17c8cf 190 return 0;
jah128 17:bf614e28668f 191 }
jah128 17:bf614e28668f 192
jah128 17:bf614e28668f 193 void Eprom::IF_write_base_ir_calibration_values(short white_values[5], short black_values[5]){
jah128 17:bf614e28668f 194 //Set calibration_set byte [29] to 1
jah128 17:bf614e28668f 195 write_firmware_byte(29,1);
jah128 17:bf614e28668f 196 for(int i=0;i<5;i++){
jah128 17:bf614e28668f 197 write_firmware_byte(30+i+i,(char) (white_values[i] >> 8));
jah128 18:9204f74069b4 198 write_firmware_byte(31+i+i,(char) (white_values[i] % 256));
jah128 17:bf614e28668f 199 }
jah128 17:bf614e28668f 200 for(int i=0;i<5;i++){
jah128 17:bf614e28668f 201 write_firmware_byte(40+i+i,(char) (black_values[i] >> 8));
jah128 18:9204f74069b4 202 write_firmware_byte(41+i+i,(char) (black_values[i] % 256));
jah128 17:bf614e28668f 203 }
jah128 17:bf614e28668f 204 sensors.IF_set_base_calibration_values(white_values[0], white_values[1], white_values[2], white_values[3], white_values[4], black_values[0], black_values[1], black_values[2], black_values[3], black_values[4]);
jah128 17:bf614e28668f 205 }
jah128 17:bf614e28668f 206
jah128 17:bf614e28668f 207 void Eprom::IF_write_base_colour_calibration_values(int white_values[4], int black_values[4]){
jah128 17:bf614e28668f 208 //Set calibration_set byte [50] to 1
jah128 17:bf614e28668f 209 write_firmware_byte(50,1);
jah128 17:bf614e28668f 210 for(int i=0;i<4;i++){
jah128 17:bf614e28668f 211 write_firmware_byte(51+i+i,(char) (black_values[i] >> 8));
jah128 18:9204f74069b4 212 write_firmware_byte(52+i+i,(char) (black_values[i] % 256));
jah128 17:bf614e28668f 213 }
jah128 17:bf614e28668f 214 for(int i=0;i<4;i++){
jah128 17:bf614e28668f 215 write_firmware_byte(59+i+i,(char) (white_values[i] >> 8));
jah128 18:9204f74069b4 216 write_firmware_byte(60+i+i,(char) (white_values[i] % 256));
jah128 17:bf614e28668f 217 }
jah128 17:bf614e28668f 218 colour.set_calibration_values(black_values[0],black_values[1],black_values[2],black_values[3],white_values[0],white_values[1],white_values[2],white_values[3]);
jah128 17:bf614e28668f 219 }
jah128 17:bf614e28668f 220
jah128 18:9204f74069b4 221 void Eprom::IF_write_motor_calibration_values(float left_motor_calibration_value, int left_motor_offset, float right_motor_calibration_value, int right_motor_offset){
jah128 18:9204f74069b4 222 //Set calibration_set byte [22] to 1
jah128 18:9204f74069b4 223 write_firmware_byte(22,1);
jah128 18:9204f74069b4 224 int left_motor_cv = left_motor_calibration_value * 16777215;
jah128 18:9204f74069b4 225 int right_motor_cv = right_motor_calibration_value * 16777215;
jah128 18:9204f74069b4 226 char lm1 = (char)(left_motor_cv >> 16);
jah128 18:9204f74069b4 227 char lm2 = (char)(left_motor_cv >> 8 % 256);
jah128 18:9204f74069b4 228 char lm3 = (char)(left_motor_cv % 256);
jah128 18:9204f74069b4 229 char rm1 = (char)(right_motor_cv >> 16);
jah128 18:9204f74069b4 230 char rm2 = (char)(right_motor_cv >> 8 % 256);
jah128 18:9204f74069b4 231 char rm3 = (char)(right_motor_cv % 256);
jah128 18:9204f74069b4 232 write_firmware_byte(23,lm1);
jah128 18:9204f74069b4 233 write_firmware_byte(24,lm2);
jah128 18:9204f74069b4 234 write_firmware_byte(25,lm3);
jah128 18:9204f74069b4 235 write_firmware_byte(26,rm1);
jah128 18:9204f74069b4 236 write_firmware_byte(27,rm2);
jah128 18:9204f74069b4 237 write_firmware_byte(28,rm3);
jah128 18:9204f74069b4 238 write_firmware_byte(67,left_motor_offset);
jah128 18:9204f74069b4 239 write_firmware_byte(68,right_motor_offset);
jah128 18:9204f74069b4 240 }
jah128 17:bf614e28668f 241
jah128 17:bf614e28668f 242 void Eprom::update_firmware(){
jah128 17:bf614e28668f 243 psi.debug("\n\nPsiSwarm Firmware Writer\n___________________________________\nUpdating firmware to version %1.1f\n",TARGET_FIRMWARE_VERSION);
jah128 17:bf614e28668f 244 display.clear_display();
jah128 17:bf614e28668f 245 display.set_position(0,0);
jah128 17:bf614e28668f 246 display.write_string("UPDATING");
jah128 17:bf614e28668f 247 display.set_position(1,0);
jah128 17:bf614e28668f 248 display.write_string("FIRMWARE");
jah128 17:bf614e28668f 249 char fv_big = (char) TARGET_FIRMWARE_VERSION;
jah128 17:bf614e28668f 250 char fv_small = (char) ((float) (TARGET_FIRMWARE_VERSION - fv_big) * 10.0f);
jah128 17:bf614e28668f 251
jah128 17:bf614e28668f 252 wait(0.5);
jah128 17:bf614e28668f 253 eprom.write_firmware(firmware_bytes[1], FD_CREATE_DAY, FD_CREATE_MONTH, FD_CREATE_YEAR, firmware_bytes[5], firmware_bytes[6], firmware_bytes[7], firmware_bytes[8],fv_big,
jah128 17:bf614e28668f 254 fv_small, has_compass, has_side_ir, has_base_ir, has_base_colour_sensor, has_top_colour_sensor, has_wheel_encoders, has_audio_pic, has_ultrasonic_sensor, has_temperature_sensor, has_recharging_circuit,
jah128 18:9204f74069b4 255 has_433_radio, motor_calibration_set, base_ir_calibration_set, base_colour_calibration_set, boot_count);
jah128 17:bf614e28668f 256 }
jah128 17:bf614e28668f 257
jah128 17:bf614e28668f 258
jah128 17:bf614e28668f 259
jah128 17:bf614e28668f 260 void Eprom::write_string(char value){
jah128 17:bf614e28668f 261 if(value==1) pc.printf("YES\n");
jah128 17:bf614e28668f 262 else pc.printf("NO\n");
jah128 17:bf614e28668f 263 }
jah128 17:bf614e28668f 264
jah128 17:bf614e28668f 265 void Eprom::write_firmware(char _flash_count, char _create_day, char _create_month, char _create_year, char _batch_number, char _serial_number, char _pcb_version_big, char _pcb_version_little, char _firmware_version_big,
jah128 17:bf614e28668f 266 char _firmware_version_little, char _has_compass, char _has_side_ir, char _has_base_ir, char _has_base_colour_sensor, char _has_top_colour_sensor, char _has_encoders, char _has_audio_pic, char _has_ultrasonic,
jah128 18:9204f74069b4 267 char _has_temperature, char _has_recharging, char _has_433_radio, char _motor_calibration_set, char _base_ir_calibration_set, char _base_colour_calibration_set, short _boot_count){
jah128 17:bf614e28668f 268 psi.debug("Writing new firmware:\n");
jah128 17:bf614e28668f 269 write_firmware_byte(0,PSI_BYTE);
jah128 17:bf614e28668f 270 _flash_count ++;
jah128 17:bf614e28668f 271 pc.printf("Flash Count: %d\n",_flash_count);
jah128 17:bf614e28668f 272 write_firmware_byte(1,_flash_count);
jah128 17:bf614e28668f 273 pc.printf("Flash Date: %d-%d-%d\n",_create_day,_create_month,_create_year);
jah128 17:bf614e28668f 274 write_firmware_byte(2,_create_day);
jah128 17:bf614e28668f 275 write_firmware_byte(3,_create_month);
jah128 17:bf614e28668f 276 write_firmware_byte(4,_create_year);
jah128 17:bf614e28668f 277 pc.printf("Serial Number: %d-%d\n",_batch_number,_serial_number);
jah128 17:bf614e28668f 278 write_firmware_byte(5,_batch_number);
jah128 17:bf614e28668f 279 write_firmware_byte(6,_serial_number);
jah128 17:bf614e28668f 280 pc.printf("PCB Version: %d.%d\n",_pcb_version_big,_pcb_version_little);
jah128 17:bf614e28668f 281 write_firmware_byte(7,_pcb_version_big);
jah128 17:bf614e28668f 282 write_firmware_byte(8,_pcb_version_little);
jah128 17:bf614e28668f 283 pc.printf("Firmware Version: %d.%d\n",_firmware_version_big,_firmware_version_little);
jah128 17:bf614e28668f 284 write_firmware_byte(9,_firmware_version_big);
jah128 17:bf614e28668f 285 write_firmware_byte(10,_firmware_version_little);
jah128 17:bf614e28668f 286 pc.printf("Has Compass: ");
jah128 17:bf614e28668f 287 write_string(_has_compass);
jah128 17:bf614e28668f 288 write_firmware_byte(11,_has_compass);
jah128 17:bf614e28668f 289 pc.printf("Has Side IR Sensors: ");
jah128 17:bf614e28668f 290 write_string(_has_side_ir);
jah128 17:bf614e28668f 291 write_firmware_byte(12,_has_side_ir);
jah128 17:bf614e28668f 292 pc.printf("Has Base IR Sensors: ");
jah128 17:bf614e28668f 293 write_string(_has_base_ir);
jah128 17:bf614e28668f 294 write_firmware_byte(13,_has_base_ir);
jah128 17:bf614e28668f 295 pc.printf("Has Base Colour Sensor: ");
jah128 17:bf614e28668f 296 write_string(_has_base_colour_sensor);
jah128 17:bf614e28668f 297 write_firmware_byte(14,_has_base_colour_sensor);
jah128 17:bf614e28668f 298 pc.printf("Has Top Colour Sensor: ");
jah128 17:bf614e28668f 299 write_string(_has_top_colour_sensor);
jah128 17:bf614e28668f 300 write_firmware_byte(15,_has_top_colour_sensor);
jah128 17:bf614e28668f 301 pc.printf("Has Wheel Encoders: ");
jah128 17:bf614e28668f 302 write_string(_has_encoders);
jah128 17:bf614e28668f 303 write_firmware_byte(16,_has_encoders);
jah128 17:bf614e28668f 304 pc.printf("Has Audio PIC: ");
jah128 17:bf614e28668f 305 write_string(_has_audio_pic);
jah128 17:bf614e28668f 306 write_firmware_byte(17,_has_audio_pic);
jah128 17:bf614e28668f 307 pc.printf("Has Ultrasonic Sensor: ");
jah128 17:bf614e28668f 308 write_string(_has_ultrasonic);
jah128 17:bf614e28668f 309 write_firmware_byte(18,_has_ultrasonic);
jah128 17:bf614e28668f 310 pc.printf("Has Temperature Sensor: ");
jah128 17:bf614e28668f 311 write_string(_has_temperature);
jah128 17:bf614e28668f 312 write_firmware_byte(19,_has_temperature);
jah128 17:bf614e28668f 313 pc.printf("Has Recharging Circuit: ");
jah128 17:bf614e28668f 314 write_string(_has_recharging);
jah128 17:bf614e28668f 315 write_firmware_byte(20,_has_recharging);
jah128 17:bf614e28668f 316 pc.printf("Has 433MHz Radio: ");
jah128 17:bf614e28668f 317 write_string(_has_433_radio);
jah128 17:bf614e28668f 318 write_firmware_byte(21,_has_433_radio);
jah128 17:bf614e28668f 319 pc.printf("Motor calibration set: ");
jah128 17:bf614e28668f 320 write_string(_motor_calibration_set);
jah128 17:bf614e28668f 321 write_firmware_byte(22,_motor_calibration_set);
jah128 17:bf614e28668f 322 pc.printf("Base IR calibration set: ");
jah128 17:bf614e28668f 323 write_string(_base_ir_calibration_set);
jah128 17:bf614e28668f 324 write_firmware_byte(29,_base_ir_calibration_set);
jah128 17:bf614e28668f 325 pc.printf("Base colour calibration set: ");
jah128 17:bf614e28668f 326 write_string(_base_colour_calibration_set);
jah128 17:bf614e28668f 327 write_firmware_byte(50,_base_colour_calibration_set);
jah128 18:9204f74069b4 328 pc.printf("Boot Count: %d\n",_boot_count);
jah128 17:bf614e28668f 329 wait(0.2);
jah128 17:bf614e28668f 330 pc.printf("_________________________________________\n");
jah128 17:bf614e28668f 331 wait(0.2);
jah128 17:bf614e28668f 332 pc.printf("VERIFYING FIRMWARE...\n");
jah128 18:9204f74069b4 333 short test_b_c = read_firmware_byte(69) << 8;
jah128 18:9204f74069b4 334 test_b_c += read_firmware_byte(70);
jah128 17:bf614e28668f 335 if(read_firmware_byte(0) == PSI_BYTE
jah128 17:bf614e28668f 336 && read_firmware_byte(1) == _flash_count
jah128 17:bf614e28668f 337 && read_firmware_byte(2) == _create_day
jah128 17:bf614e28668f 338 && read_firmware_byte(3) == _create_month
jah128 17:bf614e28668f 339 && read_firmware_byte(4) == _create_year
jah128 17:bf614e28668f 340 && read_firmware_byte(5) == _batch_number
jah128 17:bf614e28668f 341 && read_firmware_byte(6) == _serial_number
jah128 17:bf614e28668f 342 && read_firmware_byte(7) == _pcb_version_big
jah128 17:bf614e28668f 343 && read_firmware_byte(8) == _pcb_version_little
jah128 17:bf614e28668f 344 && read_firmware_byte(9) == _firmware_version_big
jah128 17:bf614e28668f 345 && read_firmware_byte(10) == _firmware_version_little
jah128 17:bf614e28668f 346 && read_firmware_byte(11) == _has_compass
jah128 17:bf614e28668f 347 && read_firmware_byte(12) == _has_side_ir
jah128 17:bf614e28668f 348 && read_firmware_byte(13) == _has_base_ir
jah128 17:bf614e28668f 349 && read_firmware_byte(14) == _has_base_colour_sensor
jah128 17:bf614e28668f 350 && read_firmware_byte(15) == _has_top_colour_sensor
jah128 17:bf614e28668f 351 && read_firmware_byte(16) == _has_encoders
jah128 17:bf614e28668f 352 && read_firmware_byte(17) == _has_audio_pic
jah128 17:bf614e28668f 353 && read_firmware_byte(18) == _has_ultrasonic
jah128 17:bf614e28668f 354 && read_firmware_byte(19) == _has_temperature
jah128 17:bf614e28668f 355 && read_firmware_byte(20) == _has_recharging
jah128 17:bf614e28668f 356 && read_firmware_byte(21) == _has_433_radio
jah128 17:bf614e28668f 357 && read_firmware_byte(22) == _motor_calibration_set
jah128 17:bf614e28668f 358 && read_firmware_byte(29) == _base_ir_calibration_set
jah128 17:bf614e28668f 359 && read_firmware_byte(50) == _base_colour_calibration_set
jah128 18:9204f74069b4 360 && test_b_c == _boot_count
jah128 17:bf614e28668f 361 ){
jah128 17:bf614e28668f 362 pc.printf("Flash successful.\n");
jah128 17:bf614e28668f 363 display.clear_display();
jah128 17:bf614e28668f 364 display.set_position(0,0);
jah128 17:bf614e28668f 365 display.write_string("FIRMWARE");
jah128 17:bf614e28668f 366 display.set_position(1,0);
jah128 17:bf614e28668f 367 display.write_string("UPDATED");
jah128 17:bf614e28668f 368 }
jah128 17:bf614e28668f 369 else {pc.printf("ERROR: Corrupt data. Flashing failed.\n");
jah128 17:bf614e28668f 370 display.clear_display();
jah128 17:bf614e28668f 371 display.set_position(0,0);
jah128 17:bf614e28668f 372 display.write_string("UPDATE");
jah128 17:bf614e28668f 373 display.set_position(1,0);
jah128 17:bf614e28668f 374 display.write_string("FAILED");
jah128 17:bf614e28668f 375 wait(1);
jah128 17:bf614e28668f 376 }
jah128 17:bf614e28668f 377
jah128 17:bf614e28668f 378 wait(0.5);
jah128 17:bf614e28668f 379 psi.debug("\nResetting...\n");
jah128 17:bf614e28668f 380 wait(0.2);
jah128 17:bf614e28668f 381 mbed_reset();
jah128 17:bf614e28668f 382 }
jah128 17:bf614e28668f 383
jah128 17:bf614e28668f 384
jah128 17:bf614e28668f 385
jah128 17:bf614e28668f 386 //PCB Features
jah128 17:bf614e28668f 387 #define HAS_COMPASS 0
jah128 17:bf614e28668f 388 #define HAS_SIDE_IR 1
jah128 17:bf614e28668f 389 #define HAS_BASE_IR 1
jah128 17:bf614e28668f 390 #define HAS_ULTRASONIC 1
jah128 17:bf614e28668f 391 #define HAS_BASE_COLOUR_SENSOR 1
jah128 17:bf614e28668f 392 #define HAS_TOP_COLOUR_SENSOR 0
jah128 17:bf614e28668f 393 #define HAS_ENCODERS 0
jah128 17:bf614e28668f 394 #define HAS_AUDIO_PIC 0
jah128 17:bf614e28668f 395 #define HAS_TEMPERATURE 1
jah128 17:bf614e28668f 396 #define HAS_RECHARGING 1
jah128 17:bf614e28668f 397 #define HAS_433_RADIO 0
jah128 17:bf614e28668f 398
jah128 17:bf614e28668f 399 //Calibration
jah128 17:bf614e28668f 400 #define MOTOR_CALIBRATION_SET 0