read (and verify) arbitrary block sizes. optionally read to file.

Author: AdamLaurie

bootload.py

@@ -31,14 +31,32 @@ def download_code(ihx_file, serial_port):
   return True
 
 def verify_code(ihx_file, serial_port):
+  can_read_any= None
   for line in ihx_file.readlines():
     record_type = int(line[7:9], 16)
     if (record_type == 0x00):
-      length= int(line[1:3], 16)
-      start_addr= int(line[3:7], 16)
-      data= line[9:9+(length*2)]
-      # we can only read 16 byte chunks
-      block_length= ((length / 16) + 1) * 16
+      length = int(line[1:3], 16)
+      start_addr = int(line[3:7], 16)
+      data = line[9:9+(length*2)]
+      # first time around, check if we can only read 16 byte chunks
+      if can_read_any == None:
+        can_read_any = False
+        do_flash_read(serial_port, start_addr, 1)
+        for read_data in serial_port:
+          read_data = read_data.strip()
+          if not read_data:
+            continue
+          if not read_data == ":00000001FF":
+            can_read_any = True
+          else:
+            break
+        if not can_read_any:
+          print "*** warning! this version of CC-Bootloader can only read 16 byte blocks!"
+          print "*** upgrade recommended!"
+      if can_read_any:
+        block_length= length
+      else:
+        block_length= ((length / 16) + 1) * 16
       print "\rVerifying %04d bytes at address: %04X" % (length, start_addr),
       do_flash_read(serial_port, start_addr, block_length)
       verify_data= ''
@@ -113,13 +131,16 @@ def do_flash_read(serial_port, start_addr, length):
   serial_port.write(":02%04X25%04X%02X\n" % (start_addr, length, chksum))
 
 
-def flash_read(serial_port, start_addr, length):
+def flash_read(ihx_file, serial_port, start_addr, length):
   do_flash_read(serial_port, start_addr, length)
   for line in serial_port:
     if not line == "\n":
+      if(ihx_file):
+        ihx_file.write(line)
+      else:
         print line,
-        if (line == ":00000001FF\n"):
-          break
+      if (line == ":00000001FF\n"):
+        break
 
 def print_usage():
   import sys
@@ -159,11 +180,11 @@ def print_usage():
     determine which page the user code starts on please check the
     USER_CODE_BASE setting in main.h.
     
-  read <start_addr> <len>
+  read <start_addr> <len> [hex_file]
 
-    Reads len bytes from flash memory starting from start_addr. start_addr and
-    len should be specified in hexadecimal (e.g. 0x1234) and len must be a multiple
-    of 16. Output is compatible with download and verify commands.
+    Reads len bytes from flash memory starting from start_addr and optionally
+    write to hex_file. start_addr and len should be specified in hexadecimal 
+    (e.g. 0x1234).
 
   verify <hex_file>
 
@@ -212,8 +233,16 @@ def print_usage():
       if (len(options) < 2):
         print_usage()
       else:
-        flash_read(serial_port, int(options[0], 16), int(options[1], 16))
-        
+        ihx_file = None
+        if(len(options) == 3):
+          try:
+            ihx_filename = options[2]
+            ihx_file = open(ihx_filename, 'w')
+            print 'reading to:', ihx_filename
+          except:
+            print "couldn't open output file:", ihx_filename
+            exit(2)
+        flash_read(ihx_file, serial_port, int(options[0], 16), int(options[1], 16))
 
     else:
       print_usage()

src/intel_hex.c

@@ -164,38 +164,44 @@ void to_hex16_ascii(char buff[], uint16_t x) {
 
 void ihx_read_print(__xdata uint8_t* start_addr, uint16_t len) {
   __xdata char buff[45];
-  uint8_t byte, sum, i;
+  uint8_t byte, sum, i, chunk;
 
-  while (len >= 0x10) {
+  while (len) {
     sum = 0;
+    if(len > 0x10)
+      chunk = 0x10;
+    else
+      chunk = len;
 
     buff[0] = ':';
-    // Record length is 0x10
-    to_hex8_ascii(&buff[1], 0x10);
-    sum += 0x10;
+    to_hex8_ascii(&buff[1], chunk);
+    sum += chunk;
     // Write address into buffer
     to_hex16_ascii(&buff[3], (uint16_t)start_addr);
     sum += (uint16_t)start_addr & 0xFF;
     sum += ((uint16_t)start_addr >> 8) & 0xFF;
     // Write record type into buffer
     to_hex8_ascii(&buff[7], 0x00);
     // Write data bytes into buffer
-    for (i=0; i<0x10; i++) {
+    for (i=0; i<chunk; i++) {
       byte = *(start_addr+i);
       sum += byte;
       to_hex8_ascii(&buff[9 + 2*i], byte);
     }
     // Write checksum into buffer
-    to_hex8_ascii(&buff[41], (uint8_t)(-(int8_t)sum));
-    buff[43] = '\n';
-    buff[44] = 0;
+    to_hex8_ascii(&buff[9 + 2*i], (uint8_t)(-(int8_t)sum));
+    buff[11 + 2*i] = '\n';
+    buff[12 + 2*i] = 0;
 
     // Print buffer over usb
     usb_putstr(buff);
 
     // Updates for next go round
-    start_addr += 0x10;
-    len -= 0x10;
+    if(len > 0x10) {
+      start_addr += 0x10;
+      len -= 0x10;
+    } else // we're done
+      len = 0;
   }
   usb_putstr(":00000001FF\n");
 }