10KB/s programming

Author: conorpp

prog/prog.ino

@@ -172,13 +172,35 @@ unsigned char c2_erase_device (void) {
   retval = c2_read_data();
 }
 
+unsigned char c2_write_sfr (unsigned char addr, unsigned char val) {
+  unsigned char retval;
+  c2_write_addr(0xB4);
+  c2_write_data(0x0A);
+  c2_poll_bit_low(INBUSY);
+  c2_poll_bit_high(OUTREADY);
+  retval = c2_read_data();
+  c2_write_data(addr);
+  c2_poll_bit_low(INBUSY);  
+  c2_write_data(0x1);
+  c2_poll_bit_low(INBUSY);  
+  c2_write_data(val);
+  c2_poll_bit_low(INBUSY);  
+}
+
 unsigned char c2_init_PI (void) {
   c2_rst();
   c2_write_addr(0x02);
   c2_write_data(0x02);
   c2_write_data(0x04);
   c2_write_data(0x01);
-  delay(20);
+
+  // set up SFRs
+  delay(25);
+  c2_write_sfr(0xff, 0x80);
+  delay(1);
+  c2_write_sfr(0xef, 0x02);
+  delay(1);
+  c2_write_sfr(0xA9, 0x00);
   return 0;
 }
 
@@ -224,9 +246,9 @@ void setup() {
 
 unsigned int i;
 unsigned char retval;
-unsigned char rx_message[250],rx_message_ptr;
+unsigned char rx_message[300],rx_message_ptr;
 unsigned char rx,main_state,bytes_to_receive,rx_state;
-unsigned char flash_buffer[250];
+unsigned char flash_buffer[300];
 unsigned long addr;
 
 unsigned char rx_state_machine (unsigned char state, unsigned char rx_char) {
@@ -249,8 +271,13 @@ unsigned char rx_state_machine (unsigned char state, unsigned char rx_char) {
   return state;  
 }
 
-void loop() {
+#define swap(x) ((((x)>>8) & 0xff) | (((x)<<8) & 0xff00))
 
+void loop() {
+  unsigned char crc;
+  unsigned char newcrc;
+  unsigned char c;
+  unsigned long coff;
   if (Serial.available()) {
     rx = Serial.read();
     rx_state = rx_state_machine(rx_state, rx);
@@ -272,11 +299,37 @@ void loop() {
           rx_state = 0;
           break;
         case 0x03:
-          addr = (((unsigned long)(rx_message[3]))<<16) + (((unsigned long)(rx_message[4]))<<8) + (((unsigned long)(rx_message[5]))<<0);
+          addr = (((unsigned long)(rx_message[4]))<<8) + (((unsigned long)(rx_message[5]))<<0);
+          crc = rx_message[6];
+          newcrc = rx_message[5] + rx_message[4];
           for (i=0;i<rx_message[2];i++) {
-            flash_buffer[i] = rx_message[i+6];
+            flash_buffer[i] = rx_message[i+7];
           }
-          c2_write_flash_block(addr,flash_buffer,rx_message[2]);
+
+          
+          for(i=0; i < rx_message[2]; i++)
+          {
+            newcrc += flash_buffer[i];
+          }
+
+          if (crc != newcrc)
+          {
+            Serial.write(0x43);
+            break;
+          }
+
+          
+          c = rx_message[2];
+          coff = 0;
+          c2_write_flash_block(addr, flash_buffer,c);
+         // while (c)
+         
+         // {
+          //  c2_write_flash_block(addr + coff, flash_buffer + coff,min(c, 4));
+          //  coff += 4;
+          //  c -= min(c, 4);
+          //}
+          //delay(1);
           Serial.write(0x83);
           rx_state = 0;
           break;

prog_server.py

@@ -12,20 +12,30 @@ class PI():
     def __init__(self, com):
         self.ser = serial.Serial(com, 1000000, timeout = 1)
 
+    def conf(self,):
+
+        # init Programming Interface (PI)
+        while True:
+            try:
+                self.ser.write('\x01\x00')
+                x =struct.unpack('B', self.ser.read(1))[0]
+                print 'x:',hex(x)
+                assert(0x81 == x)
+                break
+            except:
+                while self.ser.read(1) != '': pass
+
+        print 'PI initiated'
+
+
     def prog(self, firmware):
 
         print 'Connected'
 
         #f = open(firmware,'r').readlines()
         f = firmware.splitlines()
 
-        # init Programming Interface (PI)
-        self.ser.write('\x01\x00')
-        x =struct.unpack('B', self.ser.read(1))[0]
-        print 'x:',hex(x)
-        assert(0x81 == x)
-
-        print 'PI initiated'
+        self.conf()
 
         # erase device
         self.ser.write('\x04\x00')
@@ -51,11 +61,28 @@ def prog(self, firmware):
             buf += data
             buf_size += size
 
-            if buf_size > 175:
-                #print hex(addrh), hex(addrl), buf
-                self.ser.write([0x3, buf_size + 4, buf_size, 0, addrh, addrl])
-                self.ser.write(buf.decode('hex'))
-                assert(0x83 == struct.unpack('B', self.ser.read(1))[0])
+            if buf_size > 256 - 0x20 or i == f[-2]:
+                attempts = 0
+                while True:
+                    try:
+                        print hex(addrh), hex(addrl), buf
+                        crc = addrh + addrl
+                        crc += sum([struct.unpack('B', x)[0] for x in buf.decode('hex')])
+                        assert(len(buf.decode('hex')) == buf_size)
+                        self.ser.write([0x3, buf_size + 4 + 1, buf_size, 0, addrh, addrl, crc & 0xff])
+                        self.ser.write(buf.decode('hex'))
+                        ret = struct.unpack('B', self.ser.read(1))[0]
+                        if ret == 0x83:
+                            pass
+                        else:
+                            print 'error flash write returned ', hex(ret)
+                            raise RuntimeError('bad crc')
+                        break
+                    except Exception as e:
+                        attempts += 1
+                        self.conf()
+                        print e
+                        print 'attempts:',attempts
                 total += buf_size
                 buf_size = 0
                 buf = ''
@@ -65,6 +92,16 @@ def prog(self, firmware):
         self.ser.write('\x02\x00')
         assert(0x82 == struct.unpack('B', self.ser.read(1))[0])
 
+        # reset device
+        self.ser.write('\x02\x00')
+        assert(0x82 == struct.unpack('B', self.ser.read(1))[0])
+
+        # reset device
+        self.ser.write('\x02\x00')
+        assert(0x82 == struct.unpack('B', self.ser.read(1))[0])
+
+
+
         print 'Device reset'
 
 print 'Once'