Psi Swarm Robot / PsiSwarmV9

Psi Swarm robot library version 0.9

Dependents:   PsiSwarm_V9_Blank

Fork of PsiSwarmV9 by James Hilder

eprom.cpp@20:2b6ebe60929d, 2019-07-08 (annotated)

Committer:
richardredpath
Date:
Mon Jul 08 10:50:40 2019 +0000
Revision:
20:2b6ebe60929d
Parent:
19:3e3b03d80ea3 
Fixed deprecated warnings for callbacks throughout the library

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 19:3e3b03d80ea3 193
jah128 19:3e3b03d80ea3 194 void Eprom::firmware_writer()
jah128 19:3e3b03d80ea3 195 {
jah128 19:3e3b03d80ea3 196 psi.debug("Starting firmware writer function\n");
jah128 19:3e3b03d80ea3 197 display.clear_display();
jah128 19:3e3b03d80ea3 198 display.write_string("FIRMWARE WRITER");
jah128 19:3e3b03d80ea3 199 display.set_position(1,0);
jah128 19:3e3b03d80ea3 200 int sub_menu = 0;
jah128 19:3e3b03d80ea3 201 char _batch_number = FD_BATCH_NUMBER;
jah128 19:3e3b03d80ea3 202 char _serial_number = FD_SERIAL_NUMBER;
jah128 19:3e3b03d80ea3 203 char _create_day = FD_CREATE_DAY;
jah128 19:3e3b03d80ea3 204 char _create_month = FD_CREATE_MONTH;
jah128 19:3e3b03d80ea3 205 char _create_year = FD_CREATE_YEAR;
jah128 19:3e3b03d80ea3 206 char _pcb_version_big = FD_PCB_VERSION_BIG;
jah128 19:3e3b03d80ea3 207 char _pcb_version_little = FD_PCB_VERSION_LITTLE;
jah128 19:3e3b03d80ea3 208 char _firmware_version_big = FD_FIRMWARE_VERSION_BIG;
jah128 19:3e3b03d80ea3 209 char _firmware_version_little = FD_FIRMWARE_VERSION_LITTLE;
jah128 19:3e3b03d80ea3 210 char _has_compass = FD_HAS_COMPASS;
jah128 19:3e3b03d80ea3 211 char _has_side_ir = FD_HAS_SIDE_IR;
jah128 19:3e3b03d80ea3 212 char _has_base_ir = FD_HAS_BASE_IR;
jah128 19:3e3b03d80ea3 213 char _has_base_colour = FD_HAS_BASE_COLOUR;
jah128 19:3e3b03d80ea3 214 char _has_top_colour = FD_HAS_TOP_COLOUR;
jah128 19:3e3b03d80ea3 215 char _has_encoders = FD_HAS_ENCODERS;
jah128 19:3e3b03d80ea3 216 char _has_audio_pic = FD_HAS_AUDIO_PIC;
jah128 19:3e3b03d80ea3 217 char _has_ultrasonic = FD_HAS_ULTRASONIC;
jah128 19:3e3b03d80ea3 218 char _has_temperature = FD_HAS_TEMPERATURE;
jah128 19:3e3b03d80ea3 219 char _has_recharging = FD_HAS_RECHARGING;
jah128 19:3e3b03d80ea3 220 char _has_433_radio = FD_HAS_433_RADIO;
jah128 19:3e3b03d80ea3 221 char exit_state = 0;
jah128 19:3e3b03d80ea3 222 char old_button = 255;
jah128 19:3e3b03d80ea3 223 char button;
jah128 19:3e3b03d80ea3 224 while(exit_state == 0){
jah128 19:3e3b03d80ea3 225 button = i2c_setup.IF_get_switch_state();
jah128 19:3e3b03d80ea3 226 if(button != old_button){
jah128 19:3e3b03d80ea3 227 old_button = button;
jah128 19:3e3b03d80ea3 228 if(button == 1)// Up
jah128 19:3e3b03d80ea3 229 {
jah128 19:3e3b03d80ea3 230 switch(sub_menu){
jah128 19:3e3b03d80ea3 231 case 0: if(_batch_number == 0) _batch_number = 20;
jah128 19:3e3b03d80ea3 232 else _batch_number --;
jah128 19:3e3b03d80ea3 233 break;
jah128 19:3e3b03d80ea3 234 case 1: if(_serial_number == 0) _serial_number = 99;
jah128 19:3e3b03d80ea3 235 else _serial_number --;
jah128 19:3e3b03d80ea3 236 break;
jah128 19:3e3b03d80ea3 237 case 2: if(_create_day == 1) _create_day = 31;
jah128 19:3e3b03d80ea3 238 else _create_day --;
jah128 19:3e3b03d80ea3 239 break;
jah128 19:3e3b03d80ea3 240 case 3: if(_create_month == 1) _create_month = 12;
jah128 19:3e3b03d80ea3 241 else _create_month --;
jah128 19:3e3b03d80ea3 242 break;
jah128 19:3e3b03d80ea3 243 case 4: if(_create_year == 15) _create_year = 25;
jah128 19:3e3b03d80ea3 244 else _create_year --;
jah128 19:3e3b03d80ea3 245 break;
jah128 19:3e3b03d80ea3 246 case 5: if(_pcb_version_big == 1) _pcb_version_big = 3;
jah128 19:3e3b03d80ea3 247 else _pcb_version_big --;
jah128 19:3e3b03d80ea3 248 break;
jah128 19:3e3b03d80ea3 249 case 6: if(_pcb_version_little == 0) _pcb_version_little = 9;
jah128 19:3e3b03d80ea3 250 else _pcb_version_little --;
jah128 19:3e3b03d80ea3 251 break;
jah128 19:3e3b03d80ea3 252 case 7: if(_firmware_version_big == 1) _firmware_version_big = 3;
jah128 19:3e3b03d80ea3 253 else _firmware_version_big --;
jah128 19:3e3b03d80ea3 254 break;
jah128 19:3e3b03d80ea3 255 case 8: if(_firmware_version_little == 0) _firmware_version_little = 9;
jah128 19:3e3b03d80ea3 256 else _firmware_version_little --;
jah128 19:3e3b03d80ea3 257 break;
jah128 19:3e3b03d80ea3 258 case 9: _has_compass = 1-_has_compass; break;
jah128 19:3e3b03d80ea3 259 case 10: _has_side_ir = 1 - _has_side_ir; break;
jah128 19:3e3b03d80ea3 260 case 11: _has_base_ir = 1 - _has_base_ir; break;
jah128 19:3e3b03d80ea3 261 case 12: _has_base_colour = 1 - _has_base_colour; break;
jah128 19:3e3b03d80ea3 262 case 13: _has_top_colour = 1 - _has_top_colour; break;
jah128 19:3e3b03d80ea3 263 case 14: _has_encoders = 1 - _has_encoders; break;
jah128 19:3e3b03d80ea3 264 case 15: _has_audio_pic = 1 - _has_audio_pic; break;
jah128 19:3e3b03d80ea3 265 case 16: _has_ultrasonic = 1 - _has_ultrasonic; break;
jah128 19:3e3b03d80ea3 266 case 17: _has_temperature = 1 - _has_temperature; break;
jah128 19:3e3b03d80ea3 267 case 18: _has_recharging = 1 - _has_recharging; break;
jah128 19:3e3b03d80ea3 268 case 19: _has_433_radio = 1 - _has_433_radio; break;
jah128 19:3e3b03d80ea3 269 case 20: exit_state = 1; break;
jah128 19:3e3b03d80ea3 270 case 21: exit_state = 2; break;
jah128 19:3e3b03d80ea3 271 }
jah128 19:3e3b03d80ea3 272 }
jah128 19:3e3b03d80ea3 273 if(button == 2)// Down
jah128 19:3e3b03d80ea3 274 {
jah128 19:3e3b03d80ea3 275 switch(sub_menu){
jah128 19:3e3b03d80ea3 276 case 0: if(_batch_number == 20) _batch_number = 0;
jah128 19:3e3b03d80ea3 277 else _batch_number ++;
jah128 19:3e3b03d80ea3 278 break;
jah128 19:3e3b03d80ea3 279 case 1: if(_serial_number == 99) _serial_number = 0;
jah128 19:3e3b03d80ea3 280 else _serial_number ++;
jah128 19:3e3b03d80ea3 281 break;
jah128 19:3e3b03d80ea3 282 case 2: if(_create_day == 31) _create_day = 1;
jah128 19:3e3b03d80ea3 283 else _create_day ++;
jah128 19:3e3b03d80ea3 284 break;
jah128 19:3e3b03d80ea3 285 case 3: if(_create_month == 12) _create_month = 1;
jah128 19:3e3b03d80ea3 286 else _create_month ++;
jah128 19:3e3b03d80ea3 287 break;
jah128 19:3e3b03d80ea3 288 case 4: if(_create_year == 25) _create_year = 15;
jah128 19:3e3b03d80ea3 289 else _create_year ++;
jah128 19:3e3b03d80ea3 290 break;
jah128 19:3e3b03d80ea3 291 case 5: if(_pcb_version_big == 3) _pcb_version_big = 1;
jah128 19:3e3b03d80ea3 292 else _pcb_version_big ++;
jah128 19:3e3b03d80ea3 293 break;
jah128 19:3e3b03d80ea3 294 case 6: if(_pcb_version_little == 9) _pcb_version_little = 0;
jah128 19:3e3b03d80ea3 295 else _pcb_version_little ++;
jah128 19:3e3b03d80ea3 296 break;
jah128 19:3e3b03d80ea3 297 case 7: if(_firmware_version_big == 3) _firmware_version_big = 1;
jah128 19:3e3b03d80ea3 298 else _firmware_version_big ++;
jah128 19:3e3b03d80ea3 299 break;
jah128 19:3e3b03d80ea3 300 case 8: if(_firmware_version_little == 9) _firmware_version_little = 0;
jah128 19:3e3b03d80ea3 301 else _firmware_version_little ++;
jah128 19:3e3b03d80ea3 302 break;
jah128 19:3e3b03d80ea3 303 case 9: _has_compass = 1-_has_compass; break;
jah128 19:3e3b03d80ea3 304 case 10: _has_side_ir = 1 - _has_side_ir; break;
jah128 19:3e3b03d80ea3 305 case 11: _has_base_ir = 1 - _has_base_ir; break;
jah128 19:3e3b03d80ea3 306 case 12: _has_base_colour = 1 - _has_base_colour; break;
jah128 19:3e3b03d80ea3 307 case 13: _has_top_colour = 1 - _has_top_colour; break;
jah128 19:3e3b03d80ea3 308 case 14: _has_encoders = 1 - _has_encoders; break;
jah128 19:3e3b03d80ea3 309 case 15: _has_audio_pic = 1 - _has_audio_pic; break;
jah128 19:3e3b03d80ea3 310 case 16: _has_ultrasonic = 1 - _has_ultrasonic; break;
jah128 19:3e3b03d80ea3 311 case 17: _has_temperature = 1 - _has_temperature; break;
jah128 19:3e3b03d80ea3 312 case 18: _has_recharging = 1 - _has_recharging; break;
jah128 19:3e3b03d80ea3 313 case 19: _has_433_radio = 1 - _has_433_radio; break;
jah128 19:3e3b03d80ea3 314 case 20: exit_state = 1; break;
jah128 19:3e3b03d80ea3 315 case 21: exit_state = 2; break;
jah128 19:3e3b03d80ea3 316 }
jah128 19:3e3b03d80ea3 317 }
jah128 19:3e3b03d80ea3 318 if(button == 4)// Left
jah128 19:3e3b03d80ea3 319 {
jah128 19:3e3b03d80ea3 320 if(sub_menu == 0) sub_menu = 21;
jah128 19:3e3b03d80ea3 321 else sub_menu --;
jah128 19:3e3b03d80ea3 322
jah128 19:3e3b03d80ea3 323 }
jah128 19:3e3b03d80ea3 324 if(button == 8)// Right
jah128 19:3e3b03d80ea3 325 {
jah128 19:3e3b03d80ea3 326 if(sub_menu == 21) sub_menu = 0;
jah128 19:3e3b03d80ea3 327 else sub_menu ++;
jah128 19:3e3b03d80ea3 328 }
jah128 19:3e3b03d80ea3 329 display.set_position(1,0);
jah128 19:3e3b03d80ea3 330 char message[17];
jah128 19:3e3b03d80ea3 331 switch(sub_menu){
jah128 19:3e3b03d80ea3 332 case 0: sprintf(message,"BATCH NUMBER:%3d",_batch_number); break;
jah128 19:3e3b03d80ea3 333 case 1: sprintf(message,"SERIAL NUMBR:%3d",_serial_number); break;
jah128 19:3e3b03d80ea3 334 case 2: sprintf(message,"CREATE DAY :%3d",_create_day); break;
jah128 19:3e3b03d80ea3 335 case 3: sprintf(message,"CREATE MONTH:%3d",_create_month); break;
jah128 19:3e3b03d80ea3 336 case 4: sprintf(message,"CREATE YEAR :%3d",_create_year); break;
jah128 19:3e3b03d80ea3 337 case 5: sprintf(message,"PCB VERS BIG:%3d",_pcb_version_big); break;
jah128 19:3e3b03d80ea3 338 case 6: sprintf(message,"PCB VERS LIT:%3d",_pcb_version_little); break;
jah128 19:3e3b03d80ea3 339 case 7: sprintf(message,"FWR VERS BIG:%3d",_firmware_version_big);break;
jah128 19:3e3b03d80ea3 340 case 8: sprintf(message,"FWR VERS LIT:%3d",_firmware_version_little); break;
jah128 19:3e3b03d80ea3 341 case 9: sprintf(message,"HAS COMPASS :%s",IF_get_state(_has_compass)); break;
jah128 19:3e3b03d80ea3 342 case 10: sprintf(message,"HAS SIDE IR :%s",IF_get_state(_has_side_ir)); break;
jah128 19:3e3b03d80ea3 343 case 11: sprintf(message,"HAS BASE IR :%s",IF_get_state(_has_base_ir)); break;
jah128 19:3e3b03d80ea3 344 case 12: sprintf(message,"HAS BASE COL:%s",IF_get_state(_has_base_colour)); break;
jah128 19:3e3b03d80ea3 345 case 13: sprintf(message,"HAS TOP COL :%s",IF_get_state(_has_top_colour)); break;
jah128 19:3e3b03d80ea3 346 case 14: sprintf(message,"HAS ENCODERS:%s",IF_get_state(_has_encoders)); break;
jah128 19:3e3b03d80ea3 347 case 15: sprintf(message,"HAS AUDIOPIC:%s",IF_get_state(_has_audio_pic)); break;
jah128 19:3e3b03d80ea3 348 case 16: sprintf(message,"HAS ULTRASNC:%s",IF_get_state(_has_ultrasonic)); break;
jah128 19:3e3b03d80ea3 349 case 17: sprintf(message,"HAS TEMPERAT:%s",IF_get_state(_has_temperature)); break;
jah128 19:3e3b03d80ea3 350 case 18: sprintf(message,"HAS RECHARGE:%s",IF_get_state(_has_recharging)); break;
jah128 19:3e3b03d80ea3 351 case 19: sprintf(message,"HAS 433RADIO:%s",IF_get_state(_has_433_radio)); break;
jah128 19:3e3b03d80ea3 352 case 20: sprintf(message,"ACCEPT "); break;
jah128 19:3e3b03d80ea3 353 case 21: sprintf(message,"REJECT "); break;
jah128 19:3e3b03d80ea3 354 }
jah128 19:3e3b03d80ea3 355 display.write_string(message);
jah128 19:3e3b03d80ea3 356 }
jah128 19:3e3b03d80ea3 357 wait(0.01);
jah128 19:3e3b03d80ea3 358 }
jah128 19:3e3b03d80ea3 359 if(exit_state == 1){
jah128 19:3e3b03d80ea3 360 display.clear_display();
jah128 19:3e3b03d80ea3 361 display.write_string("WRITING FIRMWARE");
jah128 19:3e3b03d80ea3 362 char _flash_count = read_firmware_byte(1);
jah128 19:3e3b03d80ea3 363 if(_flash_count > 199) _flash_count = 0;
jah128 19:3e3b03d80ea3 364 char _motor_calibration_set = read_firmware_byte(22);
jah128 19:3e3b03d80ea3 365 if(_motor_calibration_set > 1) _motor_calibration_set = 0;
jah128 19:3e3b03d80ea3 366 char _base_ir_calibration_set = read_firmware_byte(29);
jah128 19:3e3b03d80ea3 367 if(_base_ir_calibration_set > 1) _base_ir_calibration_set = 0;
jah128 19:3e3b03d80ea3 368 char _base_colour_calibration_set = read_firmware_byte(50);
jah128 19:3e3b03d80ea3 369 if(_base_colour_calibration_set > 1) _base_colour_calibration_set = 0;
jah128 19:3e3b03d80ea3 370 int _boot_count = ((int)read_firmware_byte(69) << 8) + read_firmware_byte(70);
jah128 19:3e3b03d80ea3 371 if(_boot_count > 29999) _boot_count = 0;
jah128 19:3e3b03d80ea3 372 write_firmware(_flash_count, _create_day, _create_month, _create_year, _batch_number, _serial_number, _pcb_version_big, _pcb_version_little, _firmware_version_big,
jah128 19:3e3b03d80ea3 373 _firmware_version_little, _has_compass, _has_side_ir, _has_base_ir, _has_base_colour, _has_top_colour, _has_encoders, _has_audio_pic, _has_ultrasonic,
jah128 19:3e3b03d80ea3 374 _has_temperature, _has_recharging, _has_433_radio, _motor_calibration_set, _base_ir_calibration_set, _base_colour_calibration_set, _boot_count);
jah128 19:3e3b03d80ea3 375 } else {
jah128 19:3e3b03d80ea3 376 display.clear_display();
jah128 19:3e3b03d80ea3 377 display.write_string("CHANGES REJECTED");
jah128 19:3e3b03d80ea3 378 wait(1);
jah128 19:3e3b03d80ea3 379 psi.debug("Firmware writer settings rejected\n");
jah128 19:3e3b03d80ea3 380 display.clear_display();
jah128 19:3e3b03d80ea3 381 }
jah128 19:3e3b03d80ea3 382 wait(1);
jah128 19:3e3b03d80ea3 383 }
jah128 19:3e3b03d80ea3 384
jah128 19:3e3b03d80ea3 385 const char * Eprom::IF_get_state(char value)
jah128 19:3e3b03d80ea3 386 {
jah128 19:3e3b03d80ea3 387 if(value==1)return"YES";
jah128 19:3e3b03d80ea3 388 return"NO ";
jah128 19:3e3b03d80ea3 389 }
jah128 19:3e3b03d80ea3 390
jah128 17:bf614e28668f 391 void Eprom::IF_write_base_ir_calibration_values(short white_values[5], short black_values[5]){
jah128 17:bf614e28668f 392 //Set calibration_set byte [29] to 1
jah128 17:bf614e28668f 393 write_firmware_byte(29,1);
jah128 17:bf614e28668f 394 for(int i=0;i<5;i++){
jah128 17:bf614e28668f 395 write_firmware_byte(30+i+i,(char) (white_values[i] >> 8));
jah128 18:9204f74069b4 396 write_firmware_byte(31+i+i,(char) (white_values[i] % 256));
jah128 17:bf614e28668f 397 }
jah128 17:bf614e28668f 398 for(int i=0;i<5;i++){
jah128 17:bf614e28668f 399 write_firmware_byte(40+i+i,(char) (black_values[i] >> 8));
jah128 18:9204f74069b4 400 write_firmware_byte(41+i+i,(char) (black_values[i] % 256));
jah128 17:bf614e28668f 401 }
jah128 17:bf614e28668f 402 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 403 }
jah128 17:bf614e28668f 404
jah128 17:bf614e28668f 405 void Eprom::IF_write_base_colour_calibration_values(int white_values[4], int black_values[4]){
jah128 17:bf614e28668f 406 //Set calibration_set byte [50] to 1
jah128 17:bf614e28668f 407 write_firmware_byte(50,1);
jah128 17:bf614e28668f 408 for(int i=0;i<4;i++){
jah128 17:bf614e28668f 409 write_firmware_byte(51+i+i,(char) (black_values[i] >> 8));
jah128 18:9204f74069b4 410 write_firmware_byte(52+i+i,(char) (black_values[i] % 256));
jah128 17:bf614e28668f 411 }
jah128 17:bf614e28668f 412 for(int i=0;i<4;i++){
jah128 17:bf614e28668f 413 write_firmware_byte(59+i+i,(char) (white_values[i] >> 8));
jah128 18:9204f74069b4 414 write_firmware_byte(60+i+i,(char) (white_values[i] % 256));
jah128 17:bf614e28668f 415 }
jah128 17:bf614e28668f 416 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 417 }
jah128 17:bf614e28668f 418
jah128 18:9204f74069b4 419 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 420 //Set calibration_set byte [22] to 1
jah128 18:9204f74069b4 421 write_firmware_byte(22,1);
jah128 18:9204f74069b4 422 int left_motor_cv = left_motor_calibration_value * 16777215;
jah128 18:9204f74069b4 423 int right_motor_cv = right_motor_calibration_value * 16777215;
jah128 18:9204f74069b4 424 char lm1 = (char)(left_motor_cv >> 16);
jah128 18:9204f74069b4 425 char lm2 = (char)(left_motor_cv >> 8 % 256);
jah128 18:9204f74069b4 426 char lm3 = (char)(left_motor_cv % 256);
jah128 18:9204f74069b4 427 char rm1 = (char)(right_motor_cv >> 16);
jah128 18:9204f74069b4 428 char rm2 = (char)(right_motor_cv >> 8 % 256);
jah128 18:9204f74069b4 429 char rm3 = (char)(right_motor_cv % 256);
jah128 18:9204f74069b4 430 write_firmware_byte(23,lm1);
jah128 18:9204f74069b4 431 write_firmware_byte(24,lm2);
jah128 18:9204f74069b4 432 write_firmware_byte(25,lm3);
jah128 18:9204f74069b4 433 write_firmware_byte(26,rm1);
jah128 18:9204f74069b4 434 write_firmware_byte(27,rm2);
jah128 18:9204f74069b4 435 write_firmware_byte(28,rm3);
jah128 18:9204f74069b4 436 write_firmware_byte(67,left_motor_offset);
jah128 18:9204f74069b4 437 write_firmware_byte(68,right_motor_offset);
jah128 18:9204f74069b4 438 }
jah128 17:bf614e28668f 439
jah128 17:bf614e28668f 440 void Eprom::update_firmware(){
jah128 17:bf614e28668f 441 psi.debug("\n\nPsiSwarm Firmware Writer\n___________________________________\nUpdating firmware to version %1.1f\n",TARGET_FIRMWARE_VERSION);
jah128 17:bf614e28668f 442 display.clear_display();
jah128 17:bf614e28668f 443 display.set_position(0,0);
jah128 17:bf614e28668f 444 display.write_string("UPDATING");
jah128 17:bf614e28668f 445 display.set_position(1,0);
jah128 17:bf614e28668f 446 display.write_string("FIRMWARE");
jah128 17:bf614e28668f 447 char fv_big = (char) TARGET_FIRMWARE_VERSION;
jah128 17:bf614e28668f 448 char fv_small = (char) ((float) (TARGET_FIRMWARE_VERSION - fv_big) * 10.0f);
jah128 17:bf614e28668f 449
jah128 17:bf614e28668f 450 wait(0.5);
jah128 17:bf614e28668f 451 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 452 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 453 has_433_radio, motor_calibration_set, base_ir_calibration_set, base_colour_calibration_set, boot_count);
jah128 17:bf614e28668f 454 }
jah128 17:bf614e28668f 455
jah128 17:bf614e28668f 456
jah128 17:bf614e28668f 457
jah128 17:bf614e28668f 458 void Eprom::write_string(char value){
jah128 19:3e3b03d80ea3 459 if(value==1) psi.debug("YES\n");
jah128 19:3e3b03d80ea3 460 else psi.debug("NO\n");
jah128 17:bf614e28668f 461 }
jah128 17:bf614e28668f 462
jah128 17:bf614e28668f 463 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 464 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 465 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 466 psi.debug("Writing new firmware:\n");
jah128 17:bf614e28668f 467 write_firmware_byte(0,PSI_BYTE);
jah128 17:bf614e28668f 468 _flash_count ++;
jah128 19:3e3b03d80ea3 469 psi.debug("Flash Count: %d\n",_flash_count);
jah128 17:bf614e28668f 470 write_firmware_byte(1,_flash_count);
jah128 19:3e3b03d80ea3 471 psi.debug("Flash Date: %d-%d-%d\n",_create_day,_create_month,_create_year);
jah128 17:bf614e28668f 472 write_firmware_byte(2,_create_day);
jah128 17:bf614e28668f 473 write_firmware_byte(3,_create_month);
jah128 17:bf614e28668f 474 write_firmware_byte(4,_create_year);
jah128 19:3e3b03d80ea3 475 psi.debug("Serial Number: %d-%d\n",_batch_number,_serial_number);
jah128 17:bf614e28668f 476 write_firmware_byte(5,_batch_number);
jah128 17:bf614e28668f 477 write_firmware_byte(6,_serial_number);
jah128 19:3e3b03d80ea3 478 psi.debug("PCB Version: %d.%d\n",_pcb_version_big,_pcb_version_little);
jah128 17:bf614e28668f 479 write_firmware_byte(7,_pcb_version_big);
jah128 17:bf614e28668f 480 write_firmware_byte(8,_pcb_version_little);
jah128 19:3e3b03d80ea3 481 psi.debug("Firmware Version: %d.%d\n",_firmware_version_big,_firmware_version_little);
jah128 17:bf614e28668f 482 write_firmware_byte(9,_firmware_version_big);
jah128 17:bf614e28668f 483 write_firmware_byte(10,_firmware_version_little);
jah128 19:3e3b03d80ea3 484 psi.debug("Has Compass: ");
jah128 17:bf614e28668f 485 write_string(_has_compass);
jah128 17:bf614e28668f 486 write_firmware_byte(11,_has_compass);
jah128 19:3e3b03d80ea3 487 psi.debug("Has Side IR Sensors: ");
jah128 17:bf614e28668f 488 write_string(_has_side_ir);
jah128 17:bf614e28668f 489 write_firmware_byte(12,_has_side_ir);
jah128 19:3e3b03d80ea3 490 psi.debug("Has Base IR Sensors: ");
jah128 17:bf614e28668f 491 write_string(_has_base_ir);
jah128 17:bf614e28668f 492 write_firmware_byte(13,_has_base_ir);
jah128 19:3e3b03d80ea3 493 psi.debug("Has Base Colour Sensor: ");
jah128 17:bf614e28668f 494 write_string(_has_base_colour_sensor);
jah128 17:bf614e28668f 495 write_firmware_byte(14,_has_base_colour_sensor);
jah128 19:3e3b03d80ea3 496 psi.debug("Has Top Colour Sensor: ");
jah128 17:bf614e28668f 497 write_string(_has_top_colour_sensor);
jah128 17:bf614e28668f 498 write_firmware_byte(15,_has_top_colour_sensor);
jah128 19:3e3b03d80ea3 499 psi.debug("Has Wheel Encoders: ");
jah128 17:bf614e28668f 500 write_string(_has_encoders);
jah128 17:bf614e28668f 501 write_firmware_byte(16,_has_encoders);
jah128 19:3e3b03d80ea3 502 psi.debug("Has Audio PIC: ");
jah128 17:bf614e28668f 503 write_string(_has_audio_pic);
jah128 17:bf614e28668f 504 write_firmware_byte(17,_has_audio_pic);
jah128 19:3e3b03d80ea3 505 psi.debug("Has Ultrasonic Sensor: ");
jah128 17:bf614e28668f 506 write_string(_has_ultrasonic);
jah128 17:bf614e28668f 507 write_firmware_byte(18,_has_ultrasonic);
jah128 19:3e3b03d80ea3 508 psi.debug("Has Temperature Sensor: ");
jah128 17:bf614e28668f 509 write_string(_has_temperature);
jah128 17:bf614e28668f 510 write_firmware_byte(19,_has_temperature);
jah128 19:3e3b03d80ea3 511 psi.debug("Has Recharging Circuit: ");
jah128 17:bf614e28668f 512 write_string(_has_recharging);
jah128 17:bf614e28668f 513 write_firmware_byte(20,_has_recharging);
jah128 19:3e3b03d80ea3 514 psi.debug("Has 433MHz Radio: ");
jah128 17:bf614e28668f 515 write_string(_has_433_radio);
jah128 17:bf614e28668f 516 write_firmware_byte(21,_has_433_radio);
jah128 19:3e3b03d80ea3 517 psi.debug("Motor calibration set: ");
jah128 17:bf614e28668f 518 write_string(_motor_calibration_set);
jah128 17:bf614e28668f 519 write_firmware_byte(22,_motor_calibration_set);
jah128 19:3e3b03d80ea3 520 psi.debug("Base IR calibration set: ");
jah128 17:bf614e28668f 521 write_string(_base_ir_calibration_set);
jah128 17:bf614e28668f 522 write_firmware_byte(29,_base_ir_calibration_set);
jah128 19:3e3b03d80ea3 523 psi.debug("Base colour calibration set: ");
jah128 17:bf614e28668f 524 write_string(_base_colour_calibration_set);
jah128 17:bf614e28668f 525 write_firmware_byte(50,_base_colour_calibration_set);
jah128 19:3e3b03d80ea3 526 psi.debug("Boot Count: %d\n",_boot_count);
jah128 17:bf614e28668f 527 wait(0.2);
jah128 19:3e3b03d80ea3 528 psi.debug("_________________________________________\n");
jah128 17:bf614e28668f 529 wait(0.2);
jah128 19:3e3b03d80ea3 530 psi.debug("VERIFYING FIRMWARE...\n");
jah128 18:9204f74069b4 531 short test_b_c = read_firmware_byte(69) << 8;
jah128 18:9204f74069b4 532 test_b_c += read_firmware_byte(70);
jah128 17:bf614e28668f 533 if(read_firmware_byte(0) == PSI_BYTE
jah128 17:bf614e28668f 534 && read_firmware_byte(1) == _flash_count
jah128 17:bf614e28668f 535 && read_firmware_byte(2) == _create_day
jah128 17:bf614e28668f 536 && read_firmware_byte(3) == _create_month
jah128 17:bf614e28668f 537 && read_firmware_byte(4) == _create_year
jah128 17:bf614e28668f 538 && read_firmware_byte(5) == _batch_number
jah128 17:bf614e28668f 539 && read_firmware_byte(6) == _serial_number
jah128 17:bf614e28668f 540 && read_firmware_byte(7) == _pcb_version_big
jah128 17:bf614e28668f 541 && read_firmware_byte(8) == _pcb_version_little
jah128 17:bf614e28668f 542 && read_firmware_byte(9) == _firmware_version_big
jah128 17:bf614e28668f 543 && read_firmware_byte(10) == _firmware_version_little
jah128 17:bf614e28668f 544 && read_firmware_byte(11) == _has_compass
jah128 17:bf614e28668f 545 && read_firmware_byte(12) == _has_side_ir
jah128 17:bf614e28668f 546 && read_firmware_byte(13) == _has_base_ir
jah128 17:bf614e28668f 547 && read_firmware_byte(14) == _has_base_colour_sensor
jah128 17:bf614e28668f 548 && read_firmware_byte(15) == _has_top_colour_sensor
jah128 17:bf614e28668f 549 && read_firmware_byte(16) == _has_encoders
jah128 17:bf614e28668f 550 && read_firmware_byte(17) == _has_audio_pic
jah128 17:bf614e28668f 551 && read_firmware_byte(18) == _has_ultrasonic
jah128 17:bf614e28668f 552 && read_firmware_byte(19) == _has_temperature
jah128 17:bf614e28668f 553 && read_firmware_byte(20) == _has_recharging
jah128 17:bf614e28668f 554 && read_firmware_byte(21) == _has_433_radio
jah128 17:bf614e28668f 555 && read_firmware_byte(22) == _motor_calibration_set
jah128 17:bf614e28668f 556 && read_firmware_byte(29) == _base_ir_calibration_set
jah128 17:bf614e28668f 557 && read_firmware_byte(50) == _base_colour_calibration_set
jah128 18:9204f74069b4 558 && test_b_c == _boot_count
jah128 17:bf614e28668f 559 ){
jah128 19:3e3b03d80ea3 560 psi.debug("Flash successful.\n");
jah128 17:bf614e28668f 561 display.clear_display();
jah128 17:bf614e28668f 562 display.set_position(0,0);
jah128 17:bf614e28668f 563 display.write_string("FIRMWARE");
jah128 17:bf614e28668f 564 display.set_position(1,0);
jah128 17:bf614e28668f 565 display.write_string("UPDATED");
jah128 17:bf614e28668f 566 }
jah128 19:3e3b03d80ea3 567 else {psi.debug("ERROR: Corrupt data. Flashing failed.\n");
jah128 17:bf614e28668f 568 display.clear_display();
jah128 17:bf614e28668f 569 display.set_position(0,0);
jah128 17:bf614e28668f 570 display.write_string("UPDATE");
jah128 17:bf614e28668f 571 display.set_position(1,0);
jah128 17:bf614e28668f 572 display.write_string("FAILED");
jah128 17:bf614e28668f 573 wait(1);
jah128 17:bf614e28668f 574 }
jah128 17:bf614e28668f 575
jah128 17:bf614e28668f 576 wait(0.5);
jah128 17:bf614e28668f 577 psi.debug("\nResetting...\n");
jah128 17:bf614e28668f 578 wait(0.2);
jah128 17:bf614e28668f 579 mbed_reset();
jah128 17:bf614e28668f 580 }
jah128 17:bf614e28668f 581
jah128 17:bf614e28668f 582
jah128 17:bf614e28668f 583
jah128 17:bf614e28668f 584 //PCB Features
jah128 17:bf614e28668f 585 #define HAS_COMPASS 0
jah128 17:bf614e28668f 586 #define HAS_SIDE_IR 1
jah128 17:bf614e28668f 587 #define HAS_BASE_IR 1
jah128 17:bf614e28668f 588 #define HAS_ULTRASONIC 1
jah128 17:bf614e28668f 589 #define HAS_BASE_COLOUR_SENSOR 1
jah128 17:bf614e28668f 590 #define HAS_TOP_COLOUR_SENSOR 0
jah128 17:bf614e28668f 591 #define HAS_ENCODERS 0
jah128 17:bf614e28668f 592 #define HAS_AUDIO_PIC 0
jah128 17:bf614e28668f 593 #define HAS_TEMPERATURE 1
jah128 17:bf614e28668f 594 #define HAS_RECHARGING 1
jah128 17:bf614e28668f 595 #define HAS_433_RADIO 0
jah128 17:bf614e28668f 596
jah128 17:bf614e28668f 597 //Calibration
jah128 17:bf614e28668f 598 #define MOTOR_CALIBRATION_SET 0