Psi Swarm robot library version 0.9
Fork of PsiSwarmV9 by
eprom.cpp@19:3e3b03d80ea3, 2017-06-05 (annotated)
- Committer:
- jah128
- Date:
- Mon Jun 05 22:47:14 2017 +0000
- Revision:
- 19:3e3b03d80ea3
- Parent:
- 18:9204f74069b4
Added firmware writer
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 | 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 |