Added reading binary files, UU-encoding

The program in now able to read binary files, load them into RAM and execute. It also supports UU-encoding.

Makefile

@@ -1,6 +1,6 @@
 PROGRAM=sprog
 VERSION=0.0-alpha
-OBJS=main.o version.o sprog.o serial.o lpc.o
+OBJS=main.o version.o sprog.o serial.o uucode.o lpc.o
 CFLAGS=-Wall -Wextra -I./
 LDFLAGS=
 CC=gcc

lpc.c

@@ -3,6 +3,7 @@
 #include <stdio.h>
 #include <stdarg.h>
 #include <serial.h>
+#include <uucode.h>
 #include <lpc.h>
 
 const struct lpc_part lpc_parts[] = {
@@ -36,6 +37,7 @@ const struct lpc_part lpc_parts[] = {
 const struct sprog_family lpc_family = {
   .setup = (void*(*)(struct serial_device*)) lpc_setup,
   .init = (void(*)(void*)) lpc_init,
+  .exec = (void(*)(void*, const struct sprog_data*)) lpc_exec,
   .close = (void(*)(void*)) lpc_close
 };
   
@@ -43,8 +45,13 @@ const struct sprog_family lpc_family = {
 
 void lpc_ispmode(struct lpc_device *dev, int state);
 void lpc_reset(struct lpc_device *dev);
-int lpc_command(char *text, ...);
+void lpc_vprintf(const char *text, va_list l);
+void lpc_printf(const char *text, ...);
+int lpc_getline(char *buf);
+int lpc_command(const char *text, ...);
 int lpc_read_partid(struct lpc_device *dev);
+void lpc_write_ram(struct lpc_device *dev, const struct sprog_data *d, unsigned int addr);
+
 
 struct lpc_device *lpc_setup(struct serial_device *port) {
   struct lpc_device *dev;
@@ -60,58 +67,125 @@ void lpc_init(struct lpc_device *dev) {
   char buf[4096];
   printf("?");
   fflush(stdout);
-  if(sprog_waitdata(500)==0) {
-    printf("\r\n");
-    fflush(stdout);
-    fgets(buf, sizeof(buf), stdin);
-    if(strcmp(buf, "?\r\n")==0)
-      sprog_error("The device appears to be already synchronized\n");
-      fgets(buf, sizeof(buf), stdin); /* deny invalid command reply */
-  } else {
-    fgets(buf, sizeof(buf), stdin);
+  if(lpc_getline(buf)) {
     if(strcmp(buf, "Synchronized\r\n")==0)
       sprog_error("Synchronization successful\n");
-    printf("Synchronized\r\n");
-    fflush(stdout);
-    fgets(buf, sizeof(buf), stdin); /* deny echoed line */
-    fgets(buf, sizeof(buf), stdin);
+    lpc_printf("Synchronized\r\n");
+    lpc_getline(buf);
     if(strcmp(buf, "OK\r\n")!=0)
       sprog_error("Expected OK, received '%s'\n", buf);
     sprog_error("Sending clock frequency\n");
-    printf("12000\r\n");
-    fflush(stdout);
-    fgets(buf, sizeof(buf), stdin); /* deny echoed line */
-    fgets(buf, sizeof(buf), stdin);
+    lpc_printf("12000\r\n");
+    lpc_getline(buf);
     if(strcmp(buf, "OK\r\n")!=0)
       sprog_error("Expected OK, received '%s'\n", buf);
+  } else {
+    printf("\r\n");
+    if(lpc_getline(buf))
+      if(strcmp(buf, "?\r\n")==0)
+	sprog_error("The device appears to be already synchronized\n");
+    lpc_getline(buf); /* deny invalid command reply */
   }
   sprog_error("Reading part ID\n");
   if(lpc_read_partid(dev)==0)
     sprog_error("Found device: %s, %dkB Flash, %dkB RAM\n", dev->part->name, dev->part->flash, dev->part->ram);
 }
 
-int lpc_command(char *text, ...) {
+void lpc_exec(struct lpc_device *dev, const struct sprog_data *d) {
+  lpc_write_ram(dev, d, 0x10000400);
+  lpc_command("U 23130\r\n");
+  sprog_error("Executing code... ");
+  if(lpc_command("G %u T\r\n", 0x10000400))
+    sprog_error("Error\n");
+  else
+    sprog_error("OK\n");
+}
+
+void lpc_write_ram(struct lpc_device *dev, const struct sprog_data *d, unsigned int addr) {
+  char reply_buf[4096];
+  int last_offset;
+  int last_i;
+  int offset;
+  int checksum;
+  char buf[64];
+  int i;
+  
+  if(d->size & 3)
+    sprog_error("Invalid data size - should be aligned to 4\n");
+  
+  lpc_command("W %u %u\r\n", addr, d->size);
+  sprog_error("Writing %d bytes\n", d->size);
+  
+  last_offset = 0;
+  offset = 0;
+  sprog_progress((offset*100)/d->size);
+  checksum = 0;
+  
+  for(i=0; uuencode_line(d, buf, &offset, &checksum); i++) {
+    if((i % 20)==19)
+      lpc_printf("%u\r\n", checksum);
+    sprog_progress((offset*100)/d->size);
+  
+    if(lpc_getline(reply_buf)) {
+      if(strcmp(reply_buf, "OK\r\n")==0) {
+	last_offset = offset;
+	last_i = i;
+      } else {
+	offset = last_offset;
+	i = last_i;
+      }
+    } else
+      break;
+  }
+  
+  if(offset!=d->size)
+    sprog_error("Error while writing to RAM\n");
+}
+  
+
+int lpc_getline(char *buf) {
+  if(sprog_waitdata(500)==0)
+    return 0;
+  fgets(buf, 4096, stdin);
+  return 1;
+}
+
+void lpc_vprintf(const char *text, va_list l) {
+  char buf[4096];
+  vprintf(text, l);
+  lpc_getline(buf);
+}
+
+void lpc_printf(const char *text, ...) {
+  va_list l;
+  va_start(l, text);
+  lpc_vprintf(text, l);
+  va_end(l);
+}
+
+int lpc_command(const char *text, ...) {
   char buf[4096];
   int res;
   va_list l;
   va_start(l, text);
-  vprintf(text, l);
-  fflush(stdout);
-  fgets(buf, sizeof(buf), stdin); /* deny echoed line */
-  if(scanf("%d", &res)<1)
-    return -1;
+  lpc_vprintf(text, l);
   va_end(l);
+  lpc_getline(buf);
+  if(sscanf(buf, "%d", &res)<1)
+    return -1;
   return res;
 }
 
 int lpc_read_partid(struct lpc_device *dev) {
+  char buf[4096];
   int i;
   int res;
   unsigned int partid;
   res = lpc_command("J\r\n");
   if(res!=0)
     return res;
-  scanf("%u", &partid);
+  lpc_getline(buf);
+  sscanf(buf, "%u", &partid);
   for(i=0; lpc_parts[i].name; i++)
     if(lpc_parts[i].part_id==partid)
       break;

lpc.h

@@ -11,6 +11,7 @@ struct lpc_device {
 
 struct lpc_device *lpc_setup(struct serial_device *port);
 void lpc_init(struct lpc_device *dev);
+void lpc_exec(struct lpc_device *dev, const struct sprog_data *d);
 void lpc_close(struct lpc_device *dev);
 
 

main.c

@@ -20,11 +20,14 @@ void print_version(void);
 
 int main(int argc, char *argv[]) {
   const struct sprog_family *fam;
+  struct sprog_data d;
   int opt;
   int option_index;
   int baud;
   char port[128];
+  char path[128];
   port[0] = 0;
+  path[0] = 0;
   fam = NULL;
   
   while((opt = getopt_long(argc, argv, "p:b:f:h", sprog_options, &option_index))!=-1) {
@@ -32,6 +35,9 @@ int main(int argc, char *argv[]) {
       case 'p':
 	strncpy(port, optarg, sizeof(port));
 	break;
+      case 'e':
+	strncpy(path, optarg, sizeof(path));
+	break;
       case 'f':
 	if(strcmp(optarg, "lpc")==0)
 	  fam = &lpc_family;
@@ -70,7 +76,14 @@ int main(int argc, char *argv[]) {
     return 1;
   }
   
-  sprog_communicate(fam, port, baud);
+  if(path[0]) {
+    d.data = NULL;
+    d.size = 0;
+    sprog_load(&d, path);
+    sprog_communicate(fam, &d, port, baud);
+  } else
+    sprog_communicate(fam, NULL, port, baud);
+    
   
   return 0;
   
@@ -82,6 +95,7 @@ void usage(const char *name) {
   printf("  -p <port>, --port <port>		specify the serial port, eg. /dev/ttyS0\n");
   printf("  -f <family>, --family <family>	specify the microcontroller family, eg. lpc\n");
   printf("  -b <baud>, --baud <baud>		specify the baud rate\n");
+  printf("  -e <file>, --exec <file>		execute the given file\n");
   printf("  -h, --help				display this help\n");
   printf("  --version				print version and exit\n");
 }

serial.c

@@ -1,5 +1,6 @@
 #include <string.h>
 #include <stdlib.h>
+#include <stdarg.h>
 #include <errno.h>
 #include <unistd.h>
 #include <termios.h>
@@ -174,4 +175,3 @@ int serial_select(int nfds, fd_set *readfds, fd_set *writefds, fd_set *exceptfds
  
   return res;
 }
-

sprog.c

@@ -4,11 +4,12 @@
 #include <errno.h>
 #include <stdio.h>
 #include <unistd.h>
+#include <fcntl.h>
 #include <sys/select.h>
 #include <sys/wait.h>
 #include <sprog.h>
 
-void sprog_process(const struct sprog_family *fam, void *arg, int nstdin, int nstdout);
+void sprog_process(const struct sprog_family *fam, void *arg, const struct sprog_data *d, int nstdin, int nstdout);
 
 void sprog_error(const char *text, ...) {
   va_list l;
@@ -21,13 +22,13 @@ void sprog_sleep(int msec) {
   usleep(msec * 1000);
 }
 
-void sprog_communicate(const struct sprog_family *fam, const char *port, int baud) {
+void sprog_communicate(const struct sprog_family *fam, const struct sprog_data *d, const char *port, int baud) {
   void *arg;
   struct serial_device dev;
   
   serial_open(&dev, port, baud);
   arg = fam->setup(&dev);
-  sprog_process(fam, arg, dev.fd, dev.fd);
+  sprog_process(fam, arg, d, dev.fd, dev.fd);
 }
 
 int sprog_waitdata(int timeout) {
@@ -42,7 +43,7 @@ int sprog_waitdata(int timeout) {
   return 1;
 }
 
-void sprog_process(const struct sprog_family *fam, void *arg, int nstdin, int nstdout) {
+void sprog_process(const struct sprog_family *fam, void *arg, const struct sprog_data *d, int nstdin, int nstdout) {
   int oldstdin;
   int oldstdout;
   oldstdin = dup(0);
@@ -50,6 +51,73 @@ void sprog_process(const struct sprog_family *fam, void *arg, int nstdin, int ns
   dup2(nstdin, 0);
   dup2(nstdout, 1);
   fam->init(arg);
+  if(d->data)
+    fam->exec(arg, d);
   dup2(oldstdin, 0);
   dup2(oldstdout, 1);
 }
+
+void sprog_load(struct sprog_data *d, const char *path) {
+  char buf[4096];
+  int fd;
+  int n;
+  
+  fd = open(path, O_RDONLY);
+  if(fd<0) {
+    sprog_error("Unable to open '%s': %s\n", path, strerror(errno));
+    return;
+  }
+  
+  d->size = 0; 
+
+  while((n = read(fd, buf, sizeof(buf)))>0)
+    sprog_append_data(d, buf, n);
+    
+  if(n<0) {
+    sprog_error("Error while reading from '%s': %s\n", path, strerror(errno));
+    free(d->data);
+    d->size = 0;
+    d->data = NULL;
+    return;
+  }
+}
+
+void sprog_append_data(struct sprog_data *d, const char *data, int len) {
+  int i;
+  int alloc;
+  alloc = d->alloc;
+  
+  if(!d->data)
+    alloc = 4096;
+  
+  while((d->size+len+128)<alloc)
+    alloc *= 2;
+  
+  if(d->data)
+    d->data = realloc(d->data, alloc);
+  else
+    d->data = malloc(alloc);
+  
+  for(i=0; i<len; i++)
+    d->data[i+d->size] = data[i];
+  
+  d->alloc = alloc;
+  d->size = len;
+}
+
+void sprog_progress(int progress) {
+  char buf[80];
+  int i;
+  int w;
+  w = (progress*7)/10;
+  for(i=0; i<70; i++) {
+    if(i<=w)
+      buf[i] = ':';
+    else
+      buf[i] = ' ';
+  }
+  buf[i] = 0;
+  
+  sprog_error("\r[%s] %3d%%", buf, progress);
+}
+ 

sprog.h

@@ -4,19 +4,29 @@
 
 #define array_size(x) (sizeof(x)/sizeof(*x))
 
+struct sprog_data {
+  int size;
+  int alloc;
+  unsigned char *data;
+};
+
 struct sprog_family {
   void *(*setup)(struct serial_device *dev);
   void (*init)(void *arg);
+  void (*exec)(void *arg, const struct sprog_data *d);
   void (*close)(void *arg);
 };
-  
+
 
 extern const char sprog_version[];
-void sprog_communicate(const struct sprog_family *fam, const char *port, int baud);
-void sprog_process(const struct sprog_family *fam, void *arg, int nstdin, int nstdout);
+void sprog_communicate(const struct sprog_family *fam, const struct sprog_data *d, const char *port, int baud);
 int sprog_getline(char *buf, int len, int timeout);
 int sprog_waitdata(int timeout);
 void sprog_error(const char *text, ...);
 void sprog_sleep(int msec);
+void sprog_load(struct sprog_data *d, const char *path);
+void sprog_append_data(struct sprog_data *d, const char *data, int len);
+void sprog_progress(int progress);
+
 
 #endif

uucode.c

@@ -0,0 +1,62 @@
+#include <sprog.h>
+#include <uucode.h>
+
+/* aaaa aa|aa bbbb|bbbb cc|cc cccc */
+
+int uuencode_line(const struct sprog_data *d, char *dst, int *offset, int *checksum) {
+  char srcbuf[64];
+  unsigned char sum;
+  char *dstd;
+  int b;
+  int i;
+  
+  b = d->size - *offset;
+  if(b>45) b = 45;
+  
+  sum = 0;
+  for(i=0; i<b; i++) {
+    srcbuf[i] = d->data[*offset + i];
+    sum += srcbuf[i];
+    *checksum += srcbuf[i];
+  }
+  
+  for(i=0; i<(b & (4-1)); i++)
+    srcbuf[b+i] = 0;
+  
+  dst[0] = ' ' + b;
+  dstd = &dst[1];
+  
+  for(i=0; i<b; i+=3) {
+    dstd[0] = srcbuf[i]>>2;
+    dstd[1] = srcbuf[i]<<4 | srcbuf[i+1]>>4;
+    dstd[2] = srcbuf[i+1]<<2 | srcbuf[i+2]>>6;
+    dstd[3] = srcbuf[i];
+    dstd += 4;
+  }
+  
+  dstd[0] = sum;
+  dstd[1] = 0;
+  
+  for(i=0; i<b+2; i++) {
+    dst[i] &= 0x3f;
+    if(dst[i])
+      dst[i] += ' ';
+    else
+      dst[i] = '`';
+  }
+  
+  if(*offset >= d->size)
+    return 0;
+  
+  *offset += b;
+  return 1;
+}
+  
+  
+  
+void uudecode_line(struct sprog_data *d, const char *src, int *checksum) {
+  d = 0;
+  src = 0;
+  checksum = 0;
+  return;
+}

uucode.h

@@ -0,0 +1,9 @@
+#ifndef __UUCODE_H__
+#define __UUCODE_H__
+
+#include <sprog.h>
+
+int uuencode_line(const struct sprog_data *d, char *dst, int *offset, int *checksum);
+void uudecode_line(struct sprog_data *d, const char *src, int *checksum);
+
+#endif