
LPCXpresso1114_blinky.axf:     file format elf32-littlearm


Disassembly of section .text:

00000000 <g_pfnResetVectors>:
   0:	f0 1f 00 10 c5 01 00 00 b1 01 00 00 b5 01 00 00     ................
	...
  2c:	b9 01 00 00 00 00 00 00 00 00 00 00 bd 01 00 00     ................
  3c:	c1 01 00 00                                         ....

00000040 <IOCON_LUT>:
  40:	0c 10 1c 2c 30 34 4c 50 60 64 68 74 78 7c 80 90     ...,04LP`dhtx|..
  50:	94 a0 a4 a8 14 38 6c 98 08 28 5c 8c 40 44 00 20     .....8l..(\.@D. 
  60:	24 54 58 70 84 88 9c ac 3c 48 00 00 00 00 00 00     $TXp....<H......

00000070 <IntDefaultHandler>:
// for examination by a debugger.
//
//*****************************************************************************
__attribute__ ((section(".vector_const"))) //Replace WAKEUP_IRQHandler in exception vector
void IntDefaultHandler(void)
{
  70:	b500      	push	{lr}
  72:	e7fe      	b.n	72 <IntDefaultHandler+0x2>
	...

0000007c <g_pfnISRVectors>:
  7c:	0071 0000 0199 0000 0071 0000 0071 0000     q.......q...q...
  8c:	0071 0000 0071 0000 0071 0000 0071 0000     q...q...q...q...
  9c:	0071 0000 0071 0000 0071 0000 0071 0000     q...q...q...q...
  ac:	0071 0000 0071 0000 0071 0000 0071 0000     q...q...q...q...
  bc:	0071 0000                                   q...

000000c0 <main>:
	LPC_TMR16B0->TCR |= 1;

}

int main (void)
{
  c0:	b530      	push	{r4, r5, lr}
extern volatile uint32_t timer16_0_counter;

static void InitPLLIRC48(void)
{
    // Set PLL frequency= x4 = 48 MHz from 12 MHz IRC
    LPC_SYSCON->SYSPLLCTRL = 0x3 + (0x2<<5);
  c2:	4829      	ldr	r0, [pc, #164]	(168 <main+0xa8>)
  c4:	2343      	movs	r3, #67

    // Turn on PLL
    LPC_SYSCON->PDRUNCFG &= ~(1<<7);
  c6:	228e      	movs	r2, #142
extern volatile uint32_t timer16_0_counter;

static void InitPLLIRC48(void)
{
    // Set PLL frequency= x4 = 48 MHz from 12 MHz IRC
    LPC_SYSCON->SYSPLLCTRL = 0x3 + (0x2<<5);
  c8:	6083      	str	r3, [r0, #8]

    // Turn on PLL
    LPC_SYSCON->PDRUNCFG &= ~(1<<7);
  ca:	0092      	lsls	r2, r2, #2
  cc:	5883      	ldr	r3, [r0, r2]
  ce:	2180      	movs	r1, #128
  d0:	438b      	bics	r3, r1
  d2:	5083      	str	r3, [r0, r2]

    // Wait for PLL lock
    while(!(LPC_SYSCON->SYSPLLSTAT&1))
  d4:	4a24      	ldr	r2, [pc, #144]	(168 <main+0xa8>)
  d6:	2501      	movs	r5, #1
  d8:	68d3      	ldr	r3, [r2, #12]
  da:	422b      	tst	r3, r5
  dc:	d0fa      	beq.n	d4 <main+0x14>
}

int main (void)
{
	InitPLLIRC48();
	LPC_SYSCON->SYSAHBCLKCTRL |= ( (1<<6) | (1<<7) | (1<<16) );
  de:	4923      	ldr	r1, [pc, #140]	(16c <main+0xac>)
    // Wait for PLL lock
    while(!(LPC_SYSCON->SYSPLLSTAT&1))
        ;

    // Switch main clock from IRC to PLLOUT
    LPC_SYSCON->MAINCLKSEL = 3;
  e0:	2403      	movs	r4, #3
    LPC_SYSCON->MAINCLKUEN = 1; LPC_SYSCON->MAINCLKUEN = 0;
  e2:	2000      	movs	r0, #0
    // Wait for PLL lock
    while(!(LPC_SYSCON->SYSPLLSTAT&1))
        ;

    // Switch main clock from IRC to PLLOUT
    LPC_SYSCON->MAINCLKSEL = 3;
  e4:	6714      	str	r4, [r2, #112]
    LPC_SYSCON->MAINCLKUEN = 1; LPC_SYSCON->MAINCLKUEN = 0;
  e6:	6755      	str	r5, [r2, #116]
  e8:	6750      	str	r0, [r2, #116]
}

int main (void)
{
	InitPLLIRC48();
	LPC_SYSCON->SYSAHBCLKCTRL |= ( (1<<6) | (1<<7) | (1<<16) );
  ea:	6fcb      	ldr	r3, [r1, #124]
  ec:	4a20      	ldr	r2, [pc, #128]	(170 <main+0xb0>)
  ee:	4313      	orrs	r3, r2
  f0:	67cb      	str	r3, [r1, #124]
    LPC_SYSCON->MAINCLKUEN = 1; LPC_SYSCON->MAINCLKUEN = 0;
}

static void setupTimer16(uint16_t TimerInterval)
{
	timer16_0_counter = 0;
  f2:	4b20      	ldr	r3, [pc, #128]	(174 <main+0xb4>)

	LPC_TMR16B0->TCR |= 0x2; //Assert Timer Reset
  f4:	4920      	ldr	r1, [pc, #128]	(178 <main+0xb8>)
    LPC_SYSCON->MAINCLKUEN = 1; LPC_SYSCON->MAINCLKUEN = 0;
}

static void setupTimer16(uint16_t TimerInterval)
{
	timer16_0_counter = 0;
  f6:	6018      	str	r0, [r3, #0]

	LPC_TMR16B0->TCR |= 0x2; //Assert Timer Reset
  f8:	684b      	ldr	r3, [r1, #4]
  fa:	2202      	movs	r2, #2
  fc:	4313      	orrs	r3, r2
  fe:	604b      	str	r3, [r1, #4]
	LPC_TMR16B0->TCR &= ~0x2; //De-assert Timer Reset
 100:	684b      	ldr	r3, [r1, #4]
 102:	4393      	bics	r3, r2
 104:	604b      	str	r3, [r1, #4]

	LPC_TMR16B0->IR = 0xF;
 106:	230f      	movs	r3, #15
 108:	600b      	str	r3, [r1, #0]

	LPC_TMR16B0->MR0 = TimerInterval;
 10a:	4b1c      	ldr	r3, [pc, #112]	(17c <main+0xbc>)
 * Enable a device specific interupt in the NVIC interrupt controller.
 * The interrupt number cannot be a negative value.
 */
static __INLINE void NVIC_EnableIRQ(IRQn_Type IRQn)
{
  NVIC->ISER[0] = (1 << ((uint32_t)(IRQn) & 0x1F)); /* enable interrupt */
 10c:	4a1c      	ldr	r2, [pc, #112]	(180 <main+0xc0>)
 10e:	618b      	str	r3, [r1, #24]
 110:	2380      	movs	r3, #128
 112:	025b      	lsls	r3, r3, #9
	LPC_TMR16B0->MCR = 0x3;				/* Interrupt and Reset on MR0 */
 114:	614c      	str	r4, [r1, #20]
 116:	6013      	str	r3, [r2, #0]

	/* Enable the TIMER0 Interrupt */
	NVIC_EnableIRQ(TIMER_16_0_IRQn);

	//Start timer running
	LPC_TMR16B0->TCR |= 1;
 118:	684b      	ldr	r3, [r1, #4]
 11a:	432b      	orrs	r3, r5
 11c:	604b      	str	r3, [r1, #4]
	//However, code size can be reduced further if a PCB with the LED tied to the timer MATx pin is used
	//in conjunction with the timer's pin toggling feature.
	setupTimer16(24000);

	// Set port for LED to output
	SetupGPIO(LED_PORT,LED_BIT,GPIO_DIR_OUTPUT,GPIO_FUNC_MASK,GPIO_FUNC_0);
 11e:	4b19      	ldr	r3, [pc, #100]	(184 <main+0xc4>)
 120:	4919      	ldr	r1, [pc, #100]	(188 <main+0xc8>)
 122:	79da      	ldrb	r2, [r3, #7]
 124:	4b19      	ldr	r3, [pc, #100]	(18c <main+0xcc>)
 126:	18d2      	adds	r2, r2, r3
 128:	8813      	ldrh	r3, [r2, #0]
 12a:	400b      	ands	r3, r1
 12c:	4918      	ldr	r1, [pc, #96]	(190 <main+0xd0>)
 12e:	8013      	strh	r3, [r2, #0]
 130:	880b      	ldrh	r3, [r1, #0]
 132:	2280      	movs	r2, #128
 134:	4313      	orrs	r3, r2
 136:	800b      	strh	r3, [r1, #0]

	while (1)
	{
		//more compact code than if/else structure
		//and only updates LED at two particular count values.
		switch ( timer16_0_counter )
 138:	490e      	ldr	r1, [pc, #56]	(174 <main+0xb4>)
 13a:	23fa      	movs	r3, #250
 13c:	680a      	ldr	r2, [r1, #0]
 13e:	009b      	lsls	r3, r3, #2
 140:	429a      	cmp	r2, r3
 142:	d00a      	beq.n	15a <main+0x9a>
 144:	23fa      	movs	r3, #250
 146:	00db      	lsls	r3, r3, #3
 148:	429a      	cmp	r2, r3
 14a:	d002      	beq.n	152 <main+0x92>
 14c:	2a00      	cmp	r2, #0
 14e:	d002      	beq.n	156 <main+0x96>
 150:	e007      	b.n	162 <main+0xa2>
		{
		case 2000:
			timer16_0_counter = 0;
 152:	2300      	movs	r3, #0
 154:	600b      	str	r3, [r1, #0]
		case 0:
			ClrGPIOBit(LED_PORT, LED_BIT);
 156:	2200      	movs	r2, #0
 158:	e000      	b.n	15c <main+0x9c>
			break;

		case 1000:
			SetGPIOBit(LED_PORT, LED_BIT);
 15a:	2280      	movs	r2, #128
 15c:	4b0d      	ldr	r3, [pc, #52]	(194 <main+0xd4>)
 15e:	801a      	strh	r2, [r3, #0]
 160:	e7ea      	b.n	138 <main+0x78>

static __INLINE void __enable_fault_irq()         { __ASM volatile ("cpsie f"); }
static __INLINE void __disable_fault_irq()        { __ASM volatile ("cpsid f"); }

static __INLINE void __NOP()                      { __ASM volatile ("nop"); }
static __INLINE void __WFI()                      { __ASM volatile ("wfi"); }
 162:	bf30      	wfi
 164:	e7e8      	b.n	138 <main+0x78>
 166:	46c0      	nop			(mov r8, r8)
 168:	40048000 	.word	0x40048000
 16c:	40048004 	.word	0x40048004
 170:	000100c0 	.word	0x000100c0
 174:	10000000 	.word	0x10000000
 178:	4000c000 	.word	0x4000c000
 17c:	00005dc0 	.word	0x00005dc0
 180:	e000e100 	.word	0xe000e100
 184:	00000040 	.word	0x00000040
 188:	0000fff8 	.word	0x0000fff8
 18c:	40044000 	.word	0x40044000
 190:	50008000 	.word	0x50008000
 194:	50000200 	.word	0x50000200

00000198 <TIMER16_0_IRQHandler>:
** Returned value:		None
**
******************************************************************************/
void TIMER16_0_IRQHandler(void)
{
  LPC_TMR16B0->IR = 1;			/* clear interrupt flag */
 198:	4b03      	ldr	r3, [pc, #12]	(1a8 <TIMER16_0_IRQHandler+0x10>)
 19a:	2201      	movs	r2, #1
 19c:	601a      	str	r2, [r3, #0]
  timer16_0_counter++;
 19e:	4a03      	ldr	r2, [pc, #12]	(1ac <TIMER16_0_IRQHandler+0x14>)
 1a0:	6813      	ldr	r3, [r2, #0]
 1a2:	3301      	adds	r3, #1
 1a4:	6013      	str	r3, [r2, #0]
  return;
}
 1a6:	4770      	bx	lr
 1a8:	4000c000 	.word	0x4000c000
 1ac:	10000000 	.word	0x10000000

000001b0 <NMI_Handler>:
// simply enters an infinite loop, preserving the system state for examination
// by a debugger.
//
//*****************************************************************************
void NMI_Handler(void)
{
 1b0:	b500      	push	{lr}
 1b2:	e7fe      	b.n	1b2 <NMI_Handler+0x2>

000001b4 <HardFault_Handler>:
// interrupt.  This simply enters an infinite loop, preserving the system state
// for examination by a debugger.
//
//*****************************************************************************
void HardFault_Handler(void)
{
 1b4:	b500      	push	{lr}
 1b6:	e7fe      	b.n	1b6 <HardFault_Handler+0x2>

000001b8 <SVCall_Handler>:
    {
    }
}

void SVCall_Handler(void)
{
 1b8:	b500      	push	{lr}
 1ba:	e7fe      	b.n	1ba <SVCall_Handler+0x2>

000001bc <PendSV_Handler>:
    {
    }
}

void PendSV_Handler(void)
{
 1bc:	b500      	push	{lr}
 1be:	e7fe      	b.n	1be <PendSV_Handler+0x2>

000001c0 <SysTick_Handler>:
    {
    }
}

void SysTick_Handler(void)
{
 1c0:	b500      	push	{lr}
 1c2:	e7fe      	b.n	1c2 <SysTick_Handler+0x2>

000001c4 <Reset_Handler>:
// resetting the bits in that register) are left solely in the hands of the
// application.
//
//*****************************************************************************
void Reset_Handler(void)
{
 1c4:	b510      	push	{r4, lr}
 1c6:	490a      	ldr	r1, [pc, #40]	(1f0 <Reset_Handler+0x2c>)
 1c8:	4a0a      	ldr	r2, [pc, #40]	(1f4 <Reset_Handler+0x30>)
 1ca:	e003      	b.n	1d4 <Reset_Handler+0x10>
    // Copy the data segment initializers from flash to SRAM.
    //
    pulSrc = &_etext;
    for(pulDest = &_data; pulDest < &_edata; )
    {
        *pulDest++ = *pulSrc++;
 1cc:	780b      	ldrb	r3, [r1, #0]
 1ce:	3101      	adds	r1, #1
 1d0:	7013      	strb	r3, [r2, #0]
 1d2:	3201      	adds	r2, #1

    //
    // Copy the data segment initializers from flash to SRAM.
    //
    pulSrc = &_etext;
    for(pulDest = &_data; pulDest < &_edata; )
 1d4:	4b08      	ldr	r3, [pc, #32]	(1f8 <Reset_Handler+0x34>)
 1d6:	429a      	cmp	r2, r3
 1d8:	d3f8      	bcc.n	1cc <Reset_Handler+0x8>
 1da:	4a08      	ldr	r2, [pc, #32]	(1fc <Reset_Handler+0x38>)
 1dc:	e002      	b.n	1e4 <Reset_Handler+0x20>

    //
    // Zero fill the bss segment.
    //
	for(pulDest = &_bss; pulDest < &_ebss; pulDest++)
	  *pulDest = 0;
 1de:	2300      	movs	r3, #0
 1e0:	7013      	strb	r3, [r2, #0]
    }

    //
    // Zero fill the bss segment.
    //
	for(pulDest = &_bss; pulDest < &_ebss; pulDest++)
 1e2:	3201      	adds	r2, #1
 1e4:	4b06      	ldr	r3, [pc, #24]	(200 <Reset_Handler+0x3c>)
 1e6:	429a      	cmp	r2, r3
 1e8:	d3f9      	bcc.n	1de <Reset_Handler+0x1a>
	  *pulDest = 0;

	main() ;
 1ea:	f7ff ff69 	bl	c0 <main>
 1ee:	e7fe      	b.n	1ee <Reset_Handler+0x2a>
 1f0:	00000204 	.word	0x00000204
 1f4:	10000000 	.word	0x10000000
 1f8:	10000000 	.word	0x10000000
 1fc:	10000000 	.word	0x10000000
 200:	10000004 	.word	0x10000004
