Psi Swarm robot library version 0.9
Fork of PsiSwarmV9 by
eprom.cpp@17:bf614e28668f, 2017-06-04 (annotated)
- Committer:
- jah128
- Date:
- Sun Jun 04 13:11:09 2017 +0000
- Revision:
- 17:bf614e28668f
- Parent:
- 14:2f1ad77d281e
- Child:
- 18:9204f74069b4
Updated calibration menus, fixed some bugs in demo, create new store_line_position routine using calibrated values
Who changed what in which revision?
User | Revision | Line number | New 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 | 0:d6269d17c8cf | 114 | |
jah128 | 0:d6269d17c8cf | 115 | if(firmware_bytes[0] == PSI_BYTE) { |
jah128 | 0:d6269d17c8cf | 116 | // Parse firmware |
jah128 | 0:d6269d17c8cf | 117 | char firmware_string [8]; |
jah128 | 0:d6269d17c8cf | 118 | sprintf(firmware_string,"%d.%d",firmware_bytes[9],firmware_bytes[10]); |
jah128 | 0:d6269d17c8cf | 119 | firmware_version = atof(firmware_string); |
jah128 | 1:060690a934a9 | 120 | char pcb_version_string [8]; |
jah128 | 1:060690a934a9 | 121 | sprintf(pcb_version_string,"%d.%d",firmware_bytes[7],firmware_bytes[8]); |
jah128 | 1:060690a934a9 | 122 | pcb_version = atof(pcb_version_string); |
jah128 | 1:060690a934a9 | 123 | char serial_number_string [8]; |
jah128 | 17:bf614e28668f | 124 | if(firmware_bytes[6] > 9) sprintf(serial_number_string,"%d.%d",firmware_bytes[5],firmware_bytes[6]); |
jah128 | 17:bf614e28668f | 125 | else sprintf(serial_number_string,"%d.0%d",firmware_bytes[5],firmware_bytes[6]); |
jah128 | 1:060690a934a9 | 126 | serial_number = atof(serial_number_string); |
jah128 | 1:060690a934a9 | 127 | has_compass = firmware_bytes[11]; |
jah128 | 1:060690a934a9 | 128 | has_side_ir = firmware_bytes[12]; |
jah128 | 1:060690a934a9 | 129 | has_base_ir = firmware_bytes[13]; |
jah128 | 1:060690a934a9 | 130 | has_base_colour_sensor= firmware_bytes[14]; |
jah128 | 1:060690a934a9 | 131 | has_top_colour_sensor= firmware_bytes[15]; |
jah128 | 1:060690a934a9 | 132 | has_wheel_encoders= firmware_bytes[16]; |
jah128 | 1:060690a934a9 | 133 | has_audio_pic= firmware_bytes[17]; |
jah128 | 1:060690a934a9 | 134 | has_ultrasonic_sensor= firmware_bytes[18]; |
jah128 | 1:060690a934a9 | 135 | has_temperature_sensor= firmware_bytes[19]; |
jah128 | 1:060690a934a9 | 136 | has_recharging_circuit= firmware_bytes[20]; |
jah128 | 1:060690a934a9 | 137 | has_433_radio= firmware_bytes[21]; |
jah128 | 8:6c92789d5f87 | 138 | if(firmware_version > 1.0) { |
jah128 | 8:6c92789d5f87 | 139 | motor_calibration_set = firmware_bytes[22]; |
jah128 | 8:6c92789d5f87 | 140 | if(motor_calibration_set == 1) { |
jah128 | 8:6c92789d5f87 | 141 | left_motor_calibration_value = (float) firmware_bytes[23] * 65536; |
jah128 | 8:6c92789d5f87 | 142 | left_motor_calibration_value += ((float) firmware_bytes[24] * 256); |
jah128 | 8:6c92789d5f87 | 143 | left_motor_calibration_value += firmware_bytes[25]; |
jah128 | 8:6c92789d5f87 | 144 | left_motor_calibration_value /= 16777216; |
jah128 | 8:6c92789d5f87 | 145 | right_motor_calibration_value = (float) firmware_bytes[26] * 65536; |
jah128 | 8:6c92789d5f87 | 146 | right_motor_calibration_value += ((float) firmware_bytes[27] * 256); |
jah128 | 8:6c92789d5f87 | 147 | right_motor_calibration_value += firmware_bytes[28]; |
jah128 | 8:6c92789d5f87 | 148 | right_motor_calibration_value /= 16777216; |
jah128 | 17:bf614e28668f | 149 | } else motor_calibration_set = 0; |
jah128 | 4:1c621cb8cf0d | 150 | } else motor_calibration_set = 0; |
jah128 | 17:bf614e28668f | 151 | if(firmware_version > 1.1) { |
jah128 | 17:bf614e28668f | 152 | base_ir_calibration_set = firmware_bytes[29]; |
jah128 | 17:bf614e28668f | 153 | if(base_ir_calibration_set == 1){ |
jah128 | 17:bf614e28668f | 154 | int white_values[5]; |
jah128 | 17:bf614e28668f | 155 | int black_values[5]; |
jah128 | 17:bf614e28668f | 156 | for(int i=0;i<5;i++){ |
jah128 | 17:bf614e28668f | 157 | int k_val = i+i; |
jah128 | 17:bf614e28668f | 158 | white_values[i] = (firmware_bytes[30 + k_val] << 8) + firmware_bytes[31 + k_val]; |
jah128 | 17:bf614e28668f | 159 | black_values[i] = (firmware_bytes[40 + k_val] << 8) + firmware_bytes[41 + k_val]; |
jah128 | 17:bf614e28668f | 160 | } |
jah128 | 17:bf614e28668f | 161 | 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 | 162 | }else base_ir_calibration_set = 0; |
jah128 | 17:bf614e28668f | 163 | base_colour_calibration_set = firmware_bytes[50]; |
jah128 | 17:bf614e28668f | 164 | if(base_colour_calibration_set == 1){ |
jah128 | 17:bf614e28668f | 165 | int white_values[4]; |
jah128 | 17:bf614e28668f | 166 | int black_values[4]; |
jah128 | 17:bf614e28668f | 167 | for(int i=0;i<4;i++){ |
jah128 | 17:bf614e28668f | 168 | int k_val = i+i; |
jah128 | 17:bf614e28668f | 169 | white_values[i] = (firmware_bytes[51 + k_val] << 8) + firmware_bytes[52 + k_val]; |
jah128 | 17:bf614e28668f | 170 | black_values[i] = (firmware_bytes[59 + k_val] << 8) + firmware_bytes[60 + k_val]; |
jah128 | 17:bf614e28668f | 171 | } |
jah128 | 17:bf614e28668f | 172 | 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 | 173 | }else base_colour_calibration_set = 0; |
jah128 | 17:bf614e28668f | 174 | } else { |
jah128 | 17:bf614e28668f | 175 | base_ir_calibration_set = 0; |
jah128 | 17:bf614e28668f | 176 | base_colour_calibration_set = 0; |
jah128 | 17:bf614e28668f | 177 | } |
jah128 | 0:d6269d17c8cf | 178 | return 1; |
jah128 | 0:d6269d17c8cf | 179 | } |
jah128 | 0:d6269d17c8cf | 180 | return 0; |
jah128 | 17:bf614e28668f | 181 | } |
jah128 | 17:bf614e28668f | 182 | |
jah128 | 17:bf614e28668f | 183 | void Eprom::IF_write_base_ir_calibration_values(short white_values[5], short black_values[5]){ |
jah128 | 17:bf614e28668f | 184 | //Set calibration_set byte [29] to 1 |
jah128 | 17:bf614e28668f | 185 | write_firmware_byte(29,1); |
jah128 | 17:bf614e28668f | 186 | for(int i=0;i<5;i++){ |
jah128 | 17:bf614e28668f | 187 | write_firmware_byte(30+i+i,(char) (white_values[i] >> 8)); |
jah128 | 17:bf614e28668f | 188 | write_firmware_byte(31+i+i,(char) (white_values[i] && 0xFF)); |
jah128 | 17:bf614e28668f | 189 | } |
jah128 | 17:bf614e28668f | 190 | for(int i=0;i<5;i++){ |
jah128 | 17:bf614e28668f | 191 | write_firmware_byte(40+i+i,(char) (black_values[i] >> 8)); |
jah128 | 17:bf614e28668f | 192 | write_firmware_byte(41+i+i,(char) (black_values[i] && 0xFF)); |
jah128 | 17:bf614e28668f | 193 | } |
jah128 | 17:bf614e28668f | 194 | 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 | 195 | } |
jah128 | 17:bf614e28668f | 196 | |
jah128 | 17:bf614e28668f | 197 | void Eprom::IF_write_base_colour_calibration_values(int white_values[4], int black_values[4]){ |
jah128 | 17:bf614e28668f | 198 | //Set calibration_set byte [50] to 1 |
jah128 | 17:bf614e28668f | 199 | write_firmware_byte(50,1); |
jah128 | 17:bf614e28668f | 200 | for(int i=0;i<4;i++){ |
jah128 | 17:bf614e28668f | 201 | write_firmware_byte(51+i+i,(char) (black_values[i] >> 8)); |
jah128 | 17:bf614e28668f | 202 | write_firmware_byte(52+i+i,(char) (black_values[i] && 0xFF)); |
jah128 | 17:bf614e28668f | 203 | } |
jah128 | 17:bf614e28668f | 204 | for(int i=0;i<4;i++){ |
jah128 | 17:bf614e28668f | 205 | write_firmware_byte(59+i+i,(char) (white_values[i] >> 8)); |
jah128 | 17:bf614e28668f | 206 | write_firmware_byte(60+i+i,(char) (white_values[i] && 0xFF)); |
jah128 | 17:bf614e28668f | 207 | } |
jah128 | 17:bf614e28668f | 208 | 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 | 209 | } |
jah128 | 17:bf614e28668f | 210 | |
jah128 | 17:bf614e28668f | 211 | |
jah128 | 17:bf614e28668f | 212 | void Eprom::update_firmware(){ |
jah128 | 17:bf614e28668f | 213 | psi.debug("\n\nPsiSwarm Firmware Writer\n___________________________________\nUpdating firmware to version %1.1f\n",TARGET_FIRMWARE_VERSION); |
jah128 | 17:bf614e28668f | 214 | display.clear_display(); |
jah128 | 17:bf614e28668f | 215 | display.set_position(0,0); |
jah128 | 17:bf614e28668f | 216 | display.write_string("UPDATING"); |
jah128 | 17:bf614e28668f | 217 | display.set_position(1,0); |
jah128 | 17:bf614e28668f | 218 | display.write_string("FIRMWARE"); |
jah128 | 17:bf614e28668f | 219 | char fv_big = (char) TARGET_FIRMWARE_VERSION; |
jah128 | 17:bf614e28668f | 220 | char fv_small = (char) ((float) (TARGET_FIRMWARE_VERSION - fv_big) * 10.0f); |
jah128 | 17:bf614e28668f | 221 | |
jah128 | 17:bf614e28668f | 222 | wait(0.5); |
jah128 | 17:bf614e28668f | 223 | 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 | 224 | 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 | 17:bf614e28668f | 225 | has_433_radio, motor_calibration_set, base_ir_calibration_set, base_colour_calibration_set); |
jah128 | 17:bf614e28668f | 226 | } |
jah128 | 17:bf614e28668f | 227 | |
jah128 | 17:bf614e28668f | 228 | |
jah128 | 17:bf614e28668f | 229 | |
jah128 | 17:bf614e28668f | 230 | void Eprom::write_string(char value){ |
jah128 | 17:bf614e28668f | 231 | if(value==1) pc.printf("YES\n"); |
jah128 | 17:bf614e28668f | 232 | else pc.printf("NO\n"); |
jah128 | 17:bf614e28668f | 233 | } |
jah128 | 17:bf614e28668f | 234 | |
jah128 | 17:bf614e28668f | 235 | 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 | 236 | 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 | 17:bf614e28668f | 237 | char _has_temperature, char _has_recharging, char _has_433_radio, char _motor_calibration_set, char _base_ir_calibration_set, char _base_colour_calibration_set){ |
jah128 | 17:bf614e28668f | 238 | psi.debug("Writing new firmware:\n"); |
jah128 | 17:bf614e28668f | 239 | write_firmware_byte(0,PSI_BYTE); |
jah128 | 17:bf614e28668f | 240 | _flash_count ++; |
jah128 | 17:bf614e28668f | 241 | pc.printf("Flash Count: %d\n",_flash_count); |
jah128 | 17:bf614e28668f | 242 | write_firmware_byte(1,_flash_count); |
jah128 | 17:bf614e28668f | 243 | pc.printf("Flash Date: %d-%d-%d\n",_create_day,_create_month,_create_year); |
jah128 | 17:bf614e28668f | 244 | write_firmware_byte(2,_create_day); |
jah128 | 17:bf614e28668f | 245 | write_firmware_byte(3,_create_month); |
jah128 | 17:bf614e28668f | 246 | write_firmware_byte(4,_create_year); |
jah128 | 17:bf614e28668f | 247 | pc.printf("Serial Number: %d-%d\n",_batch_number,_serial_number); |
jah128 | 17:bf614e28668f | 248 | write_firmware_byte(5,_batch_number); |
jah128 | 17:bf614e28668f | 249 | write_firmware_byte(6,_serial_number); |
jah128 | 17:bf614e28668f | 250 | pc.printf("PCB Version: %d.%d\n",_pcb_version_big,_pcb_version_little); |
jah128 | 17:bf614e28668f | 251 | write_firmware_byte(7,_pcb_version_big); |
jah128 | 17:bf614e28668f | 252 | write_firmware_byte(8,_pcb_version_little); |
jah128 | 17:bf614e28668f | 253 | pc.printf("Firmware Version: %d.%d\n",_firmware_version_big,_firmware_version_little); |
jah128 | 17:bf614e28668f | 254 | write_firmware_byte(9,_firmware_version_big); |
jah128 | 17:bf614e28668f | 255 | write_firmware_byte(10,_firmware_version_little); |
jah128 | 17:bf614e28668f | 256 | pc.printf("Has Compass: "); |
jah128 | 17:bf614e28668f | 257 | write_string(_has_compass); |
jah128 | 17:bf614e28668f | 258 | write_firmware_byte(11,_has_compass); |
jah128 | 17:bf614e28668f | 259 | pc.printf("Has Side IR Sensors: "); |
jah128 | 17:bf614e28668f | 260 | write_string(_has_side_ir); |
jah128 | 17:bf614e28668f | 261 | write_firmware_byte(12,_has_side_ir); |
jah128 | 17:bf614e28668f | 262 | pc.printf("Has Base IR Sensors: "); |
jah128 | 17:bf614e28668f | 263 | write_string(_has_base_ir); |
jah128 | 17:bf614e28668f | 264 | write_firmware_byte(13,_has_base_ir); |
jah128 | 17:bf614e28668f | 265 | pc.printf("Has Base Colour Sensor: "); |
jah128 | 17:bf614e28668f | 266 | write_string(_has_base_colour_sensor); |
jah128 | 17:bf614e28668f | 267 | write_firmware_byte(14,_has_base_colour_sensor); |
jah128 | 17:bf614e28668f | 268 | pc.printf("Has Top Colour Sensor: "); |
jah128 | 17:bf614e28668f | 269 | write_string(_has_top_colour_sensor); |
jah128 | 17:bf614e28668f | 270 | write_firmware_byte(15,_has_top_colour_sensor); |
jah128 | 17:bf614e28668f | 271 | pc.printf("Has Wheel Encoders: "); |
jah128 | 17:bf614e28668f | 272 | write_string(_has_encoders); |
jah128 | 17:bf614e28668f | 273 | write_firmware_byte(16,_has_encoders); |
jah128 | 17:bf614e28668f | 274 | pc.printf("Has Audio PIC: "); |
jah128 | 17:bf614e28668f | 275 | write_string(_has_audio_pic); |
jah128 | 17:bf614e28668f | 276 | write_firmware_byte(17,_has_audio_pic); |
jah128 | 17:bf614e28668f | 277 | pc.printf("Has Ultrasonic Sensor: "); |
jah128 | 17:bf614e28668f | 278 | write_string(_has_ultrasonic); |
jah128 | 17:bf614e28668f | 279 | write_firmware_byte(18,_has_ultrasonic); |
jah128 | 17:bf614e28668f | 280 | pc.printf("Has Temperature Sensor: "); |
jah128 | 17:bf614e28668f | 281 | write_string(_has_temperature); |
jah128 | 17:bf614e28668f | 282 | write_firmware_byte(19,_has_temperature); |
jah128 | 17:bf614e28668f | 283 | pc.printf("Has Recharging Circuit: "); |
jah128 | 17:bf614e28668f | 284 | write_string(_has_recharging); |
jah128 | 17:bf614e28668f | 285 | write_firmware_byte(20,_has_recharging); |
jah128 | 17:bf614e28668f | 286 | pc.printf("Has 433MHz Radio: "); |
jah128 | 17:bf614e28668f | 287 | write_string(_has_433_radio); |
jah128 | 17:bf614e28668f | 288 | write_firmware_byte(21,_has_433_radio); |
jah128 | 17:bf614e28668f | 289 | pc.printf("Motor calibration set: "); |
jah128 | 17:bf614e28668f | 290 | write_string(_motor_calibration_set); |
jah128 | 17:bf614e28668f | 291 | write_firmware_byte(22,_motor_calibration_set); |
jah128 | 17:bf614e28668f | 292 | pc.printf("Base IR calibration set: "); |
jah128 | 17:bf614e28668f | 293 | write_string(_base_ir_calibration_set); |
jah128 | 17:bf614e28668f | 294 | write_firmware_byte(29,_base_ir_calibration_set); |
jah128 | 17:bf614e28668f | 295 | pc.printf("Base colour calibration set: "); |
jah128 | 17:bf614e28668f | 296 | write_string(_base_colour_calibration_set); |
jah128 | 17:bf614e28668f | 297 | write_firmware_byte(50,_base_colour_calibration_set); |
jah128 | 17:bf614e28668f | 298 | wait(0.2); |
jah128 | 17:bf614e28668f | 299 | pc.printf("_________________________________________\n"); |
jah128 | 17:bf614e28668f | 300 | wait(0.2); |
jah128 | 17:bf614e28668f | 301 | pc.printf("VERIFYING FIRMWARE...\n"); |
jah128 | 17:bf614e28668f | 302 | if(read_firmware_byte(0) == PSI_BYTE |
jah128 | 17:bf614e28668f | 303 | && read_firmware_byte(1) == _flash_count |
jah128 | 17:bf614e28668f | 304 | && read_firmware_byte(2) == _create_day |
jah128 | 17:bf614e28668f | 305 | && read_firmware_byte(3) == _create_month |
jah128 | 17:bf614e28668f | 306 | && read_firmware_byte(4) == _create_year |
jah128 | 17:bf614e28668f | 307 | && read_firmware_byte(5) == _batch_number |
jah128 | 17:bf614e28668f | 308 | && read_firmware_byte(6) == _serial_number |
jah128 | 17:bf614e28668f | 309 | && read_firmware_byte(7) == _pcb_version_big |
jah128 | 17:bf614e28668f | 310 | && read_firmware_byte(8) == _pcb_version_little |
jah128 | 17:bf614e28668f | 311 | && read_firmware_byte(9) == _firmware_version_big |
jah128 | 17:bf614e28668f | 312 | && read_firmware_byte(10) == _firmware_version_little |
jah128 | 17:bf614e28668f | 313 | && read_firmware_byte(11) == _has_compass |
jah128 | 17:bf614e28668f | 314 | && read_firmware_byte(12) == _has_side_ir |
jah128 | 17:bf614e28668f | 315 | && read_firmware_byte(13) == _has_base_ir |
jah128 | 17:bf614e28668f | 316 | && read_firmware_byte(14) == _has_base_colour_sensor |
jah128 | 17:bf614e28668f | 317 | && read_firmware_byte(15) == _has_top_colour_sensor |
jah128 | 17:bf614e28668f | 318 | && read_firmware_byte(16) == _has_encoders |
jah128 | 17:bf614e28668f | 319 | && read_firmware_byte(17) == _has_audio_pic |
jah128 | 17:bf614e28668f | 320 | && read_firmware_byte(18) == _has_ultrasonic |
jah128 | 17:bf614e28668f | 321 | && read_firmware_byte(19) == _has_temperature |
jah128 | 17:bf614e28668f | 322 | && read_firmware_byte(20) == _has_recharging |
jah128 | 17:bf614e28668f | 323 | && read_firmware_byte(21) == _has_433_radio |
jah128 | 17:bf614e28668f | 324 | && read_firmware_byte(22) == _motor_calibration_set |
jah128 | 17:bf614e28668f | 325 | && read_firmware_byte(29) == _base_ir_calibration_set |
jah128 | 17:bf614e28668f | 326 | && read_firmware_byte(50) == _base_colour_calibration_set |
jah128 | 17:bf614e28668f | 327 | |
jah128 | 17:bf614e28668f | 328 | ){ |
jah128 | 17:bf614e28668f | 329 | pc.printf("Flash successful.\n"); |
jah128 | 17:bf614e28668f | 330 | display.clear_display(); |
jah128 | 17:bf614e28668f | 331 | display.set_position(0,0); |
jah128 | 17:bf614e28668f | 332 | display.write_string("FIRMWARE"); |
jah128 | 17:bf614e28668f | 333 | display.set_position(1,0); |
jah128 | 17:bf614e28668f | 334 | display.write_string("UPDATED"); |
jah128 | 17:bf614e28668f | 335 | } |
jah128 | 17:bf614e28668f | 336 | else {pc.printf("ERROR: Corrupt data. Flashing failed.\n"); |
jah128 | 17:bf614e28668f | 337 | display.clear_display(); |
jah128 | 17:bf614e28668f | 338 | display.set_position(0,0); |
jah128 | 17:bf614e28668f | 339 | display.write_string("UPDATE"); |
jah128 | 17:bf614e28668f | 340 | display.set_position(1,0); |
jah128 | 17:bf614e28668f | 341 | display.write_string("FAILED"); |
jah128 | 17:bf614e28668f | 342 | wait(1); |
jah128 | 17:bf614e28668f | 343 | } |
jah128 | 17:bf614e28668f | 344 | |
jah128 | 17:bf614e28668f | 345 | wait(0.5); |
jah128 | 17:bf614e28668f | 346 | psi.debug("\nResetting...\n"); |
jah128 | 17:bf614e28668f | 347 | wait(0.2); |
jah128 | 17:bf614e28668f | 348 | mbed_reset(); |
jah128 | 17:bf614e28668f | 349 | } |
jah128 | 17:bf614e28668f | 350 | |
jah128 | 17:bf614e28668f | 351 | |
jah128 | 17:bf614e28668f | 352 | |
jah128 | 17:bf614e28668f | 353 | //PCB Features |
jah128 | 17:bf614e28668f | 354 | #define HAS_COMPASS 0 |
jah128 | 17:bf614e28668f | 355 | #define HAS_SIDE_IR 1 |
jah128 | 17:bf614e28668f | 356 | #define HAS_BASE_IR 1 |
jah128 | 17:bf614e28668f | 357 | #define HAS_ULTRASONIC 1 |
jah128 | 17:bf614e28668f | 358 | #define HAS_BASE_COLOUR_SENSOR 1 |
jah128 | 17:bf614e28668f | 359 | #define HAS_TOP_COLOUR_SENSOR 0 |
jah128 | 17:bf614e28668f | 360 | #define HAS_ENCODERS 0 |
jah128 | 17:bf614e28668f | 361 | #define HAS_AUDIO_PIC 0 |
jah128 | 17:bf614e28668f | 362 | #define HAS_TEMPERATURE 1 |
jah128 | 17:bf614e28668f | 363 | #define HAS_RECHARGING 1 |
jah128 | 17:bf614e28668f | 364 | #define HAS_433_RADIO 0 |
jah128 | 17:bf614e28668f | 365 | |
jah128 | 17:bf614e28668f | 366 | //Calibration |
jah128 | 17:bf614e28668f | 367 | #define MOTOR_CALIBRATION_SET 0 |