File content as of revision 0:f8cf4fdf6ab4:

/*
  dynamic load the binary file.
    binary -> Flash 0x00078000 & run

  lpc17xx.ld
        IROM (rx) : ORIGIN = 0x00078000, LENGTH = 32k
        IRAM0 (rwx) : ORIGIN = 0x10002000, LENGTH = 24k

  startup_LPC17xx.c
        //void Reset_Handler(void) __attribute__((__interrupt__));
        void Reset_Handler(void);

  compiled.bin --> test.dat
*/
#include    "mbed.h"
#include    "IAP.h"
#include <new>

#define     MEM_SIZE        256
#define     TARGET_SECTOR    29

LocalFileSystem local("local");

void    memdump( char *p, int n );
int     isprint( int c );

IAP     iap;

extern "C"
void Default_Handler() {
    printf("Default Handler!\n");
    exit(-1);
}

extern "C"
void HardFault_Handler() {
    printf("Hard Fault!\n");
    exit(-1);
}

void no_memory () {
    printf("panic: can't allocate to memory!\r\n");
    exit(-1);
}

int jump (int vect) {
    void (*func)();
    unsigned int *p;

    p = (unsigned int *)(sector_start_adress[ TARGET_SECTOR ] + 4 * vect);
    func = (void (*)())*p;
    printf( "func %08x (%d)\r\n", (unsigned int)func, vect);
    func();
    return 0;
}

void SysTick_Handler(void) {
    jump(15);
}

int main() {
    FILE *fp;
    int i, r, s;
    char buf[MEM_SIZE];
    char *heap;

    set_new_handler(no_memory); // new handler function

    printf( "device-ID = 0x%08X, serial# = 0x%08X, CPU running %dkHz\r\n", iap.read_ID(), iap.read_serial(), SystemCoreClock / 1000 );
    printf( "user reserved flash area: start_address=0x%08X, size=%d bytes\r\n", iap.reserved_flash_area_start(), iap.reserved_flash_area_size() );

    r   = iap.blank_check( TARGET_SECTOR, TARGET_SECTOR );
    printf( "blank check result = 0x%08X\r\n", r );

    //  erase sector, if required
    
    if ( r == SECTOR_NOT_BLANK ) {
        iap.prepare( TARGET_SECTOR, TARGET_SECTOR );
        r = iap.erase( TARGET_SECTOR, TARGET_SECTOR );
        printf( "erase result       = 0x%08X\r\n", r );
    }

    // copy File to Flash
    fp = fopen("/local/test.dat", "r");
    if (fp) {
        iap.prepare( TARGET_SECTOR, TARGET_SECTOR );
        s = 0;
        for (i = 0;; i ++) {
            r = fread(buf, sizeof(char), MEM_SIZE, fp);
            if (r <= 0) break;
            s = s + r;
            r = iap.write(buf, sector_start_adress[TARGET_SECTOR] + MEM_SIZE * i, MEM_SIZE);
            printf( "copied: File(0x%08X)->Flash(0x%08X) for %d bytes. (result=0x%08X)\n", buf, sector_start_adress[ TARGET_SECTOR ] + MEM_SIZE * i, MEM_SIZE, r );
        }
        fclose(fp);
        printf("writable %d bytes. (%d)\r\n", s, i);
    }

    memdump( sector_start_adress[ TARGET_SECTOR ], 16);

    heap = (char*)malloc(2);
    printf("stack %08x, heap %08x\r\n", (unsigned int)&heap, (unsigned int)heap);

    {
        register unsigned int _control __asm("control");
        register unsigned int _msp __asm("msp");
        register unsigned int _psp __asm("psp");
        printf("MSP %08x, PSP %08x, CONTROL %x\r\n", _msp, _psp, _control & 3);
    }
    
    jump(1);

    printf("exit\r\n");
    return 0;
}


void memdump( char *base, int n ) {
    unsigned int    *p;

    printf( "  memdump from 0x%08X for %d bytes", (unsigned long)base, n );

    p   = (unsigned int *)((unsigned int)base & ~(unsigned int)0x3);

    for ( int i = 0; i < (n >> 2); i++, p++ ) {
        if ( !(i % 4) )
            printf( "\r\n  0x%08X :", (unsigned int)p );

        printf( " %08X", *p );
    }

    printf( "\r\n" );
}