Initial LPC1114 hacks. Load a command into RAM via the bootloader and

Makefile

@@ -0,0 +1,14 @@
+CROSS_COMPILE = arm-none-eabi-
+
+CC = $(CROSS_COMPILE)gcc
+OBJCOPY = $(CROSS_COMPILE)objcopy
+
+CFLAGS = -mcpu=cortex-m0 -mthumb -O -nostdlib -std=gnu99 -fno-toplevel-reorder
+
+all: first.bin
+
+first.elf: first.o
+	$(CC) $(CFLAGS) -T first.ld -o $@ $<
+
+%.bin: %.elf
+	$(OBJCOPY) -Obinary $< $@

README

@@ -0,0 +1,4 @@
+Initial LPC1114 hacks
+
+Michael Hope <michaelh@juju.net.nz>  2012
+

first.c

@@ -0,0 +1,76 @@
+#include <stdint.h>
+
+#define pREG32 (REG32 *)
+typedef volatile uint32_t REG32;
+#define UART_BASE_ADDRESS                         (0x40008000)
+
+#define UART_U0LSR_THRE                           ((unsigned int) 0x00000020)
+#define UART_U0LSR                                (*(pREG32 (0x40008014)))
+
+/*  Receive buffer */
+#define UART_U0RBR                                (*(pREG32 (0x40008000)))
+
+#define GPIO_GPIO2_BASE                           (0x50020000)
+
+#define GPIO_GPIO2DATA                            (*(pREG32 (0x50023FFC)))    // Port data register
+#define GPIO_GPIO2DIR                             (*(pREG32 (0x50028000)))    // Data direction register
+
+void pwm(int level, int top);
+
+void start(void)
+{
+  GPIO_GPIO2DIR = 0xFFFF;
+
+  int top = 100;
+
+  for (;;)
+    {
+      for (int level = 0; level <= top; level++)
+	{
+	  pwm(level, top);
+	}
+      for (int level = top; level >= 0; level--)
+	{
+	  pwm(level, top);
+	}
+    }
+}
+
+void pwm(int level, int top)
+{
+  int runs = 100;
+
+  for (int run = 0; run < runs; run++)
+    {
+      GPIO_GPIO2DATA = 0;
+      
+      for (volatile int j = 0; j < level; j++)
+	;
+      
+      GPIO_GPIO2DATA = 1;
+      
+      for (volatile int j = level; j <= top; j++)
+	;
+    }
+}
+
+void startx(void)
+{
+  GPIO_GPIO2DIR = 0xFFFF;
+
+  for (;;)
+
+  for (int i = 'a'; i <= 'z'; i++)
+    {
+      while ((UART_U0LSR & UART_U0LSR_THRE) == 0)
+	;
+
+      UART_U0RBR = i;
+
+      GPIO_GPIO2DATA = i & 1;
+
+      for (volatile int j = 0; j < 100000; j++)
+	{
+	}
+    }
+}

first.ld

@@ -0,0 +1,9 @@
+/* Dump everything into RAM */
+
+SECTIONS
+     {
+       . = 0x10000400;
+       .text : { *(.text) }
+       .data : { *(.data) }
+       .bss : { *(.bss) }
+     }

prog.py

@@ -0,0 +1,194 @@
+import serial
+import sys
+import time
+import binascii
+import random
+
+class Error(Exception):
+    pass
+
+RETURN_CODE = {
+    0: 'CMD_SUCCESS',
+    1: 'INVALID_COMMAND',
+    2: 'SRC_ADDR_ERROR',
+    3: 'DST_ADDR_ERROR',
+    4: 'SRC_ADDR_NOT_MAPPED',
+    5: 'DST_ADDR_NOT_MAPPED',
+    6: 'COUNT_ERROR',
+    7: 'INVALID_SECTOR',
+    8: 'SECTOR_NOT_BLANK',
+    9: 'SECTOR_NOT_PREPARED_FOR_WRITE_OPERATION',
+    10: 'COMPARE_ERROR',
+    11: 'BUSY',
+    12: 'PARAM_ERROR',
+    13: 'ADDR_ERROR',
+    14: 'ADDR_NOT_MAPPED',
+    15: 'CMD_LOCKED',
+    16: 'INVALID_CODE',
+    17: 'INVALID_BAUD_RATE',
+    18: 'INVALID_STOP_BIT',
+    19: 'CODE_READ_PROTECTION_ENABLED ',
+}
+
+class LPC:
+    SYNCHRONIZED = 'Synchronized\r\n'
+    OK = 'OK\r\n'
+
+    def __init__(self):
+        self.port = serial.Serial('/dev/ttyUSB0', 115200, timeout=0.5)
+
+    def log(self, msg, eol=True):
+        if eol:
+            print msg
+        else:
+            print msg,
+
+    def set_reset(self, level):
+        self.port.setDTR(level == 0)
+
+    def set_bsl(self, level):
+        self.port.setRTS(level == 0)
+
+    def sync(self):
+        for tries in range(3):
+            self.set_bsl(0)
+            self.set_reset(1)
+            self.set_reset(0)
+            self.set_reset(1)
+
+            self.read(100)
+        
+            self.write('?')
+
+            got = self.read(len(self.SYNCHRONIZED))
+
+            if got == self.SYNCHRONIZED:
+                self.send('Synchronized')
+                got = self.read(len(self.OK))
+
+                if got == self.OK:
+                    self.send('12000')
+
+                    got = self.read(len(self.OK))
+                    if got == self.OK:
+                        self.log(self.execute('N', (int, int, int, int)))
+                        return
+
+    def load(self, address, data):
+        chunk = 512
+        per_line = 45
+
+        for offset in range(0, len(data), 512):
+            part = data[offset:offset+512]
+
+            self.send('W %d %d' % (address + offset, len(part)))
+            self.check_ok()
+
+            for micro in range(0, len(part), per_line):
+                encoded = binascii.b2a_uu(part[micro:micro+per_line])
+                assert encoded.endswith('\n')
+                encoded = encoded[:-1]
+
+                self.send(encoded)
+
+            check = sum(ord(x) for x in part)
+            self.send('%d' % check)
+
+            got = self.readline()
+
+            if got == 'OK':
+                pass
+            elif got == 'RESEND':
+                raise Error('Checksum error on write')
+            else:
+                raise Error('Protocol error')
+
+    def go(self, address):
+        self.execute('G', (), address, 'T')
+
+        while True:
+            try:
+                self.execute('J', (int, ))
+                break
+            except Error:
+                self.read(100)
+                time.sleep(0.1)
+
+    def unlock(self):
+        self.execute('U', (), 23130)
+
+    def check_ok(self):
+        assert self.readline() == '0'
+
+    def execute(self, command, result, *kargs):
+        send = command
+
+        for arg in kargs:
+            send += ' %s' % arg
+
+        self.send(send)
+
+        code = int(self.readline())
+
+        if code != 0:
+            raise Error(RETURN_CODE[code])
+
+        values = []
+
+        for t in result:
+            values.append(t(self.readline()))
+
+        return values
+
+    def readline(self):
+        v = ''
+
+        self.log('<', eol=False)
+
+        try:
+            while True:
+                got = self.read(1, True)
+
+                if got == '':
+                    raise Error('No response')
+
+                if got == '\r':
+                    got = self.read(1, True)
+
+                    if got == '\n':
+                        return v
+                else:
+                    v += got
+        finally:
+            self.log('')
+
+    def write(self, v):
+        self.log('> %r' % v)
+        self.port.write(v)
+
+    def send(self, v):
+        v += '\r\n'
+
+        self.write(v)
+        got = self.read(len(v))
+
+        if got != v:
+            raise Error('Echo error.  Sent %r, got %r' % (v, got))
+
+    def read(self, limit, partial=False):
+        got = self.port.read(limit)
+
+        if partial:
+            self.log('%r' % got, eol=False)
+        else:
+            self.log('< %r' % got)
+
+        return got
+
+l = LPC()
+l.sync()
+
+bin = open('first.bin', 'rb').read()
+l.unlock()
+l.load(0x10000400, bin)
+l.go(0x10000400)