Sometimes, the most difficult part when dealing with I2C is to differentiate the communication direction: which signal is sent to which device. Hence, this simple trick should be useful.

I2C Debugging Trick

Things to notice is that:

• It only works for two devices debugging
• The hump that is caused by the resistor should not exceed the threshold of maximum VInput (ie not exceeding 0.3V for CMOS device or 0.7V for TTL device)

Let’s continue the last post with the real interrupt based program: UART0 interrupt-based loopback. The program example will echoing anything that is sent to the serial port, but since it’s not checking whether the TX FIFO is empty or not during the loopback, some data may be lost if you sent a file (or sending a lot of data).

The whole application can be downloaded here.

The UART peripheral on LPC17xx works similar to the other LPC2000 series. The initialisation steps are:

// Change P0.2 and P0.3 mode to TXD0 and RXD0, assuming the each pins are pulled up (PINMODE = 00),
// and open drain mode is off (PINMODE_OD = 0).
// If you have to set the PINMODE, don’t pull down the TXD0 pin.
PINCON->PINSEL0 = (1 << 4) | (1 << 6);

// Set 8N1 mode
UART0->LCR &= ~STOP_1_BIT & ~PARITY_NONE;
UART0->LCR |= CHAR_8_BIT;

// Set the baud rate (ie. fill up the DLM, DLL, and FDR)
uart_set_baudrate(baudrate);

// Enable TX and RX FIFO. This step is optional, but since UART’s FIFO is there, and we’ve paid
// for it, I’d like to enable it.
UART0->FCR |= FIFO_ENABLE;

// Set FIFO to trigger when at least 14 characters available (only needed if FIFO is enabled)
UART0->FCR |= (3 << 6);

// Enable UART RX interrupt (for LPC17xx UART). Note, there’s 3 different interrupt under UART0
// interrupt (TX buffer empty/ THRE, RX buffer full / RDA, or character received timeout / CTI)
// Read LPC17xx user manual for the details
UART0->IER = RBR_IRQ_ENABLE;

// Enable the UART interrupt (for Cortex-CM3 NVIC)
NVIC_EnableIRQ(UART0_IRQn);

If you have work with LPC2000 series before, the whole initialisation code is similar, except for the last part ‘NVIC_EnableIRQ(UART0_IRQn)’. The NVIC_EnableIRQ() is used to enable the UART0 interrupt on NVIC.

The next step, after the UART initialisation, is to enable the global interrupt, like this:

int main(void) {
uart_init(115200);
__enable_irq();

while (1) {
__WFI();
}

return 0;
}

The __enable_irq() is a macro from ‘core_cm3.h’, which will be expanded to ‘asm volatile(“cpsie i”)’. The __WFI() is also a macro for ‘asm volatile(“wfi”)’, to enter the sleep mode until the interrupt comes.

Now, how to handle the UART0 interrupt ? Take a look at your startup code:

void __attribute__((weak)) UART0_IRQHandler(void);      // 21: UART0
// ….
__attribute__ ((section(“.cs3.interrupt_vector”)))
void (* const g_pfnVectors[])(void) = {
//..
UART0_IRQHandler, // 21: UART0
};
//..
#pragma weak UART0_IRQHandler       = Default_Handler // 21: UART0

The startup code said that UART0 interrupt handler is named as UART0_IRQHandler, and it’s temporarily linked to Default_Handler(). It means that if you declare a function named: ‘void UART0_IRQHandler(void)’, the temporary link to Default_Handler() will be overridden. That’s how you’re handling the interrupt, by creating the same function name as in the startup file:

/*
* UART0 interrupt handler
*/
void UART0_IRQHandler(void) {
switch(UART0->IIR & 0×0E) {
case RDA_INTERRUPT:
case CTI_INTERRUPT:
// Loopback to send
UART0->THR = UART0->RBR;
break;
}
}

In the interrupt handler, we still need to read IIR register, since LPC17xx implementation multiplexed several interrupts into a single interrupt.

Cortex-M3 has NVIC (Nested Vector Interrupt Controller), a kind of peripheral, to support up to 255 interrupts.

Other than that, it also has WIC (Wakeup Interrupt Controller), which similar to NVIC, but it doesn’t need any clock to run. Hence it can be used to detect any interrupt during sleep mode without burning energy (no need to have any clock running on system at all).

Since WIC is only available on rev2 Cortex-M3 (currently only LPC17xx that have it), this post will only discuss the NVIC control.

Configurable Priority vs Unconfigurable Priority Interrupt

On Cortex-M3, the exceptions / interrupts are divided into two categories, based on their priority: configurable and unconfigurable. The unconfigurable priority interrupts have fixed priority, and consist of 3 interrupts:

1. Reset. Invoked on power on and reset
2. Non Maskable Interrupt. An external interrupt (activated by external pin) that is unstoppable except by reset.
3. Hard fault. Any fault that is not handled by other fault handlers (memory management fault, bus fault, usage fault) will activate this interrupt. The interrupt is also activated when the other fault handlers are turned off

Those interrupts / exceptions are the basic interrupts that are expected to be handled by the application (read: MUST be implemented by application). The priority is started at -3 for Reset, -2 for NMI, and -1 for Hard fault.

The rest of 252 interrupts are priority configurable, starting at 0 (the highest priority) until 252 (the lowest priority).

Global Interrupt Enable / Disable

During the initial reset, NVIC is turned off. Therefore, the processor cannot receive any interrupts (except for NMI, Reset interrupt, and hard fault). To turn on the interrupts with configurable priority:

asm volatile (“cpsie i”);

“CPSIE I” is a assembly instruction to enable the priority configurable interrupts. Actually, it’s a shortcut to this longer procedure

asm volatile (“MOVS r0, #0\n\
             MSR PRIMASK, r0″);

To turn off the priority configurable interrupts:

asm volatile (“cpsid i”);

Or, taking the longer non-atomic procedure:

asm volatile (“MOVS r0, #1\n\
               MSR PRIMASK, r0″);

Actually, if it is needed, the hard fault interrupt can be turned off as well (along with the priority configurable interrupts) with this command:

asm volatile (“cpsid f”);

Or, using longer non-atomic procedure

asm volatile (“MOVS r0, #1\n\
               MSR FAULTMASK, r0″);

To turn on the hard fault interrupt with the other priority configurable interrupts, use:

asm volatile (“cpsie f”);

Or, using longer non-atomic procedure

asm volatile (“MOVS r0, #0\n\
               MSR FAULTMASK, r0″);

Enabling / Disabling Group of Interrupts

Since you have up to 255 interrupts, it’s odd to have just single global interrupt on/off. Hence, ARM created a register to enable/disable group of interrupts, based on their priority, the BASEPRI. If you set the BASEPRI, the interrupts with the same priority level or lower (ie. the priority number is bigger than BASEPRI) will be masked.

Here’s how to set it:

asm volatile (“MOVS r0, #5\n\
               MSR BASEPRI, r0″);

The above code will mask the interrupts with priority 5 or below. To reset/disable the BASEPRI, just replace #5 with #0.

Enabling / Disabling Specific Interrupts

This one is very easy. If you look at the Cortex-M3 technical manual, the only thing that you need to do is to set IRQ X ‘Set Enable Register’ (ISER) or ‘Clear Enable Register’ (ICER). For example, to turn on TIMER0 interrupts (Match0, Match1, Capture0, Capture1) on LPC1766, you can use:

NVIC->ISER[0] = (1 << 1);

// Or if you have downloaded CMSIS library, you can use:

NVIC_EnableIRQ(TIMER0_IRQn);

The NVIC_EnableIRQ() is in core_cm3.h file at CMSIS library source code. Don’t forget to include “LPC17xx.h” too, before using these functions from core_cm3.h

The interesting part of Cortex-M3 is SysTick, an additional timer, provided by ARM, to switch the process context on RTOS. ARM was hoping that by using SysTick, most of RTOS will be portable from vendor to vendors.

But I’m a bit curious on how to use it. Hence, here’s the simple demo on how to use SysTick on Cortex-M3.main.c

/*
* main.c
*
*  Created on: 10-Aug-2009
*      Author: kunil
*/

#include “LPC17xx.h”
#include “core_cm3.h”

/*
* Linker file variables
*/
extern void __sidata;
extern void __sdata;
extern void __edata;
extern void __sbss;
extern void __ebss;

static int main(void);
static void setup_SysTick(void);
static void setup_LEDs(void);
static void display_current_time(void);

static unsigned int u32_current_time;

/*
* Override the standard Reset_Handler() on startup_LPC1766
*/
void Reset_Handler(void) {
unsigned int *source, *destination;

// Copy data section from ROM to RAM
source = (unsigned int *) &__sidata;
for (destination = (unsigned int *) &__sdata; destination
< (unsigned int *) &__edata; destination++) {
*destination = *source;
}

// Clear the BSS section
for (destination = (unsigned int *) &__sbss; destination
< (unsigned int *) &__ebss; destination++) {
*destination = 0;
}

main();

// If main() ever return, this will hold it
while(1);
}

/*
* Override the standard SysTick_Handler() on startup_LPC1766
*/
void SysTick_Handler(void) {
u32_current_time++;
}

int main(void) {
setup_SysTick();
setup_LEDs();
while (1) {
/* Wait for interrupt..a.k.a sleep until interrupt */
asm volatile (“wfi”);
display_current_time();
}
}

static void setup_SysTick(void) {
/* The upper limit of SysTick
*
* Since the MCU clock will be equal to internal RC (assumming the PLL is not
* activated), 4000000 value will generate 1s interrupt
*
* The value is counted at 1 (not zero). Hence -1 offset is introduced
*/
SysTick->LOAD = (4000000 – 1);
/* SysTick control register
*
* SYSTICK_CLKSOURCE = 1 means the timer will use CPU (core)’s clock
* SYSTICK_TICKINT = 1 means the SysTick interrupt is activated on NVIC
* SYSTICK_ENABLE = 1 means enable SysTick
*/
SysTick->CTRL = (1 << SYSTICK_CLKSOURCE) | (1< }

static void setup_LEDs(void) {
// Enable P1.28, P1.29, and P1.31 as output
GPIO1->FIODIR = (1 << 28) | (1 << 29) | (1 << 31);
// Enable P2.2 – P2.6 as output
GPIO2->FIODIR = (1 << 2) | (1 << 3) | (1 << 4) | (1 << 5) | (1 << 6);
}

static void display_current_time(void) {
/* Accessing the pins directly
*
* u32_current_time[0] = P1.28
* u32_current_time[1] = P1.29
* u32_current_time[2] = P1.31
* u32_current_time[3] = P2.2
* u32_current_time[4] = P2.3
* u32_current_time[5] = P2.4
* u32_current_time[6] = P2.5
* u32_current_time[7] = P2.6
*/
GPIO1->FIOPIN = 0;
GPIO2->FIOPIN = 0;

GPIO1->FIOPIN |= (((u32_current_time & 0×03) >> 0) << 28);
GPIO1->FIOPIN |= (((u32_current_time & 0×04) >> 2) << 31);
GPIO2->FIOPIN |= (((u32_current_time & 0xF8) >> 3) <<  2);
}

To use the source code, you will need the ‘cm3_core.h’, ’system_LPC17xx.h and ‘LPC17xx.h’ file from CMSIS website. I’m using ver 1.20 source code from their site, and also my own C start up / linker file.

startup_LPC17xx.c

/*
* startup_LPC1766.c – Startup file for LPC1766 Cortex-M3
*
* @author: kunilkuda_at_gmail_dot_com
*/
extern void __cs3_stack; ///< This is global variable from linker script

/* We gave ‘weak’ attribute, so these functions can be aliased into a single
* function
*/
void __attribute__((weak)) Reset_Handler(void);     /* Reset Handler */
void __attribute__((weak)) NMI_Handler(void);       /* NMI Handler */
void __attribute__((weak)) HardFault_Handler(void); /* Hard Fault Handler */
void __attribute__((weak)) MemManage_Handler(void); /* MPU Fault Handler */
void __attribute__((weak)) BusFault_Handler(void);  /* Bus Fault Handler */
void __attribute__((weak)) UsageFault_Handler(void);/* Usage Fault Handler */
void __attribute__((weak)) SVC_Handler(void);       /* SVCall Handler */
void __attribute__((weak)) DebugMon_Handler(void);  /* Debug Monitor Handler */
void __attribute__((weak)) PendSV_Handler(void);    /* PendSV Handler */
void __attribute__((weak)) SysTick_Handler(void);   /* SysTick Handler */

/*
* Ask GCC to put this array into .cs3.interrupt_vector section
*/
__attribute__ ((section(“.cs3.interrupt_vector”)))
void (* const g_pfnVectors[])(void) = {
&__cs3_stack,       // The initial stack pointer
Reset_Handler,      // The reset handler
NMI_Handler,        // The NMI handler
HardFault_Handler,  // The hard fault handler
MemManage_Handler,  // The MPU fault handler
BusFault_Handler,   // The bus fault handler
UsageFault_Handler, // The usage fault handler
0,                  // Reserved
0,                  // Reserved
0,                  // Reserved
0,                  // Reserved
SVC_Handler,        // SVCall handler
DebugMon_Handler,   // Debug monitor handler
0,                  // Reserved
PendSV_Handler,     // The PendSV handler
SysTick_Handler,    // The SysTick handler
};

/* Here’s how to alias multiple functions into single function
*/
void Default_Handler(void);
#pragma weak NMI_Handler        = Default_Handler /* NMI handler */
#pragma weak HardFault_Handler  = Default_Handler /* Hard Fault handler */
#pragma weak MemManage_Handler  = Default_Handler /* MPU Fault Handler */
#pragma weak BusFault_Handler   = Default_Handler /* Bus Fault Handler */
#pragma weak UsageFault_Handler = Default_Handler /* Usage Fault Handler */
#pragma weak SVC_Handler        = Default_Handler /* SVCall Handler */
#pragma weak DebugMon_Handler   = Default_Handler /* Debug Monitor Handler */
#pragma weak PendSV_Handler     = Default_Handler /* PendSV Handler */
#pragma weak SysTick_Handler    = Default_Handler /* SysTick Handler */

void Default_Handler(void) {
while (1);
}

extern int main(void);
void Reset_Handler(void) {
main();

// If main() ever exit, this should hold MCU from running wild
while(1);
}

LPC1766.ld

/*
* Define the supported output formats – elf32-littlearm is the
*  default
*/  
OUTPUT_FORMAT(“elf32-littlearm”, “elf32-bigarm”, “elf32-littlearm”)   

/* Define the target architecture */  
OUTPUT_ARCH(arm)   

/* Define the system entry point */  
ENTRY(Reset_Handler)   

/* Define the memory layout for the board */
SECTIONS  
{  
/* LPC1766 flash is at 0×0000_0000 */
.flash 0×00000000 :
{
/* Tell the linker to collect any .cs3.interrupt_vector section to this
address */  
KEEP(*(.cs3.interrupt_vector));

/* Collect the executable parts here */
*(.text .text.*);
/* Collect the const variables here */
*(.rodata .rodata.*);

__sidata = .;
}

/*
* This section refers to variables with init value. The init values are
* stored on ROM, but addressed on RAM (otherwise the variables cannot be
* manipulated).
*
* This section will be loaded at 0×10000000, the start of LPC1766 RAM
*/
.data_at_ram 0×10000000: AT (LOADADDR(.flash) + SIZEOF(.flash))
{
__sdata = .;
*(.data .data.*);
__edata = .;
}

.ram :
{
__sbss = .;
/* Collect the global / static variables, without init value here */
*(.bss .bss.*);
__ebss = .;
}

/* Set __cs3_stack to point the end of memory
* This one depends on your MCU. I’m using LPC1766 with 256kB flash and
* 32kB RAM
*/  

__cs3_stack = 0×10000000 + (32 * 1024);
}

To compile the files:

# arm-none-eabi-gcc -O2 -ffunction-sections -fdata-sections -g3 -Wall -c -mcpu=cortex-m3 -mthumb -omain.o main.c
# arm-none-eabi-gcc -O2 -ffunction-sections -fdata-sections -g3 -Wall -c -mcpu=cortex-m3 -mthumb -ostartup_LPC1766.o startup_LPC1766.c
# arm-none-eabi-gcc -Wl,–gc-sections -Wl,-Map,LPC1766_Systick_Interrupt.map -Wl,-T,/home/kunil/workspace/LPC1766_Systick_Interrupt/LPC1766.ld -oLPC1766_Systick_Interrupt.elf  main.o startup_LPC1766.o

To generate the HEX file:

# arm-none-eabi-objcopy -j .flash -j .data_at_ram -O ihex LPC1766_Systick_Interrupt.elf LPC1766_Systick_Interrupt.hex

The eclipse project file can be downloaded from here.

As tradition for new comers, I created my own ‘hello world’ using Cortex-M3’s assembly using Codesourcery’s GCC assembler. The code below has been tested on LPC1766 – Keil’s MCB1700 board. It will turn on/off the LEDs on the board.

Here’s the code:

/* Simple startup file for Cortex-M3 */

/* Thumb-2 instructions are only supported in unified syntax mode */
.syntax unified

/* Vector table definition */
.section “.cs3.interrupt_vector”
.long  __cs3_stack                 /* Top of Stack                 */
.long  Reset_Handler               /* Reset Handler                */
.long  NMI_Handler                 /* NMI Handler                  */
.long  HardFault_Handler           /* Hard Fault Handler           */
.long  MemManage_Handler           /* MPU Fault Handler            */
.long  BusFault_Handler            /* Bus Fault Handler            */
.long  UsageFault_Handler          /* Usage Fault Handler          */
.long  0                           /* Reserved                     */
.long  0                           /* Reserved                     */
.long  0                           /* Reserved                     */
.long  0                           /* Reserved                     */
.long  SVC_Handler                 /* SVCall Handler               */
.long  DebugMon_Handler            /* Debug Monitor Handler        */
.long  0                           /* Reserved                     */
.long  PendSV_Handler              /* PendSV Handler               */
.long  SysTick_Handler             /* SysTick Handler              */

/* Vendor specific interrupts
*  —- Not implemented
*/

/* Program section */
.section “.text”

/* Declare as thumb function. Otherwise it will not be linked
* correctly
*/
.thumb_func
/* Export the symbol so linker can see this */
.global Reset_Handler
Reset_Handler:
/* Jump to main(), a thumb function */
LDR     R0, =main
BX      R0
/* If main() ever exit, this should hold MCU from running wild */
B       .

/* This is how the lazy guy doing it: by aliasing all the
* interrupts into single address
*/
.thumb_func
NMI_Handler:
.thumb_func
HardFault_Handler:
.thumb_func
MemManage_Handler:
.thumb_func
BusFault_Handler:
.thumb_func
UsageFault_Handler:
.thumb_func
SVC_Handler:
.thumb_func
DebugMon_Handler:
.thumb_func
PendSV_Handler:
.thumb_func
SysTick_Handler:
B    . /* while(1); */

The startup file contains the initial vector address. Save it into ’startup_lpc17xx.S’ file, then compile it using:

# arm-none-eabi-as -mcpu=cortex-m3 -ostartup_lpc17xx.o startup_lpc17xx.S

Then, here comes the main file to blink the LEDs on MCB1700:

/*
* Blinky program for MCB1768 – ARM Cortex-M3
*
* The LEDs are at these pins:
* – P1.28, P1.29, P1.31
* – P2.2, P2.3, P2.4, P2.5, P2.6
*
*/
/* Thumb-2 instructions are only supported in unified syntax mode */
.syntax unified
/* Put these codes into .text section */
.section “.text”
/* Declare main() as global..Otherwise the linker won’t find it */
.global main
/* Declare as thumb function..Otherwise it may not linked correctly */
.thumb_func
main:
/* Set the pins direction as output */
LDR     R0, =set_gpio_dir
BLX     R0
loop:
LDR     R0, =clear_leds
BLX     R0
LDR     R0, =delay
BLX     R0
LDR     R0, =set_leds
BLX     R0
LDR     R0, =delay
BLX     R0
B       loop

.thumb_func
set_gpio_dir:
/* P1.28, P1.29, and P1.31 direction mode is located at
* FP1DIR (0×2009_C020).
*
* P1.28 -> Bit[28] -> Output dir : 1
* P1.29 -> Bit[29] -> Output dir : 1
* P1.31 -> Bit[31] -> Output dir : 1
*/
MOVW    R3, #0xC020
MOVT    R3, #0×2009
/* b1011_0000_0000_0000_0000_0000_0000_0000 */
MOVW    R2, #0×0000
MOVT    R2, #0xB000
STR     R2, [R3, #0]

/* P2.2, P2.3, P2.4, P2.5, and P2.6 function mode is located at
* FP2DIR (0×2009_C040).
*
* P2.2  -> Bit[2] -> Output dir : 1
* P2.3  -> Bit[3] -> Output dir : 1
* P2.4  -> Bit[4] -> Output dir : 1
* P2.5  -> Bit[5] -> Output dir : 1
* P2.6  -> Bit[6] -> Output dir : 1
*/
MOVW    R3, #0xC040
MOVT    R3, #0×2009
/* b0000_0000_0000_0000_0000_0000_0111_1100 */
MOVW    R2, #0×007C
MOVT    R2, #0×0000
STR     R2, [R3, #0]

BX      LR

.thumb_func
set_leds:
/* P1.28, P1.29, and P1.31 set is located at
* FP1SET (0×2009_C038).
*
* P1.28 -> Bit[28]
* P1.29 -> Bit[29]
* P1.31 -> Bit[31]
*/
MOVW    R3, #0xC038
MOVT    R3, #0×2009
/* b1011_0000_0000_0000_0000_0000_0000_0000 */
MOVW    R2, #0×0000
MOVT    R2, #0xB000
STR     R2, [R3, #0]

/* P2.2, P2.3, P2.4, P2.5, and P2.6 set is located at
* FP2SET (0×2009_C058).
*
* P2.2  -> Bit[2]
* P2.3  -> Bit[3]
* P2.4  -> Bit[4]
* P2.5  -> Bit[5]
* P2.6  -> Bit[6]
*/
MOVW    R3, #0xC058
MOVT    R3, #0×2009
/* b0000_0000_0000_0000_0000_0000_0111_1100 */
MOVW    R2, #0×007C
MOVT    R2, #0×0000
STR     R2, [R3, #0]

BX      LR

.thumb_func
clear_leds:
/* P1.28, P1.29, and P1.31 clear is located at
* FP1CLR (0×2009_C03C).
*
* P1.28 -> Bit[28]
* P1.29 -> Bit[29]
* P1.31 -> Bit[31]
*/
MOVW    R3, #0xC03C
MOVT    R3, #0×2009
/* b1011_0000_0000_0000_0000_0000_0000_0000 */
MOVW    R2, #0×0000
MOVT    R2, #0xB000
STR     R2, [R3, #0]

/* P2.2, P2.3, P2.4, P2.5, and P2.6 clear is located at
* FP2CLR (0×2009_C05C).
*
* P2.2  -> Bit[2]
* P2.3  -> Bit[3]
* P2.4  -> Bit[4]
* P2.5  -> Bit[5]
* P2.6  -> Bit[6]
*/
MOVW    R3, #0xC05C
MOVT    R3, #0×2009
/* b0000_0000_0000_0000_0000_0000_0111_1100 */
MOVW    R2, #0×007C
MOVT    R2, #0×0000
STR     R2, [R3, #0]

BX      LR

.thumb_func
delay:
MOVW    R3, #0xFFFF
MOVT    R3, #0×0000
__delay_loop:
CBZ     R3, __delay_exit
SUB     R3, R3, #1
B       __delay_loop
__delay_exit:
BX      LR

You may find it not very optimized, but who cares =) It’s only a ‘hello world’ after all. Anyway, save the file into ‘blinky.S’, and compile it with:

# arm-none-eabi-as -mcpu=cortex-m3 -oblinky.o blinky.S

Now, to combine both object files (startup_lpc17xx.o and blinky.o), we will call the linker. The linker needs to know the device’s memory layout, which is put inside the linker file. Here’s the linker file:

/*
* Define the supported output formats – elf32-littlearm is the
*  default
*/  
OUTPUT_FORMAT(“elf32-littlearm”, “elf32-bigarm”, “elf32-littlearm”)   

/* Define the target architecture */  
OUTPUT_ARCH(arm)   

/* Define the system entry point */  
ENTRY(Reset_Handler)   

/* Define the memory layout for the board */
SECTIONS  
{  
/* LPC1766 flash is at 0×0000_0000 */
.flash 0×00000000 :
{
/* Tell the linker to collect any .cs3.interrupt_vector section to this
address */  
KEEP(*(.cs3.interrupt_vector));

/* Collect the executable parts here */
*(.text .text.*);
/* Collect the const variables here */
*(.rodata .rodata.*);

__sidata = .;
}

/*
* This section refers to variables with init value. The init values are
* stored on ROM, but addressed on RAM (otherwise the variables cannot be
* manipulated).
*
* This section will be loaded at 0×10000000, the start of LPC1766 RAM
*/
.data_at_ram 0×10000000: AT (LOADADDR(.flash) + SIZEOF(.flash))
{
__sdata = .;
*(.data .data.*);
__edata = .;
}

.ram :
{
__sbss = .;
/* Collect the global / static variables, without init value here */
*(.bss .bss.*);
__ebss = .;
}

/* Set __cs3_stack to point the end of memory
* This one depends on your MCU. I’m using LPC1766 with 256kB flash and
* 32kB RAM
*/  

__cs3_stack = 0×10000000 + (32 * 1024);
}

Save it into ‘linked.ld’. Now, you can combine all the object files into real ARM executable using this command:

# arm-none-eabi-gcc -Wl,–gc-sections -Wl,-Map,LPC1766_Blinky_Assembly.map -Wl,-T/home/kunil/workspace/LPC1766_Blinky_Assembly/linker.ld -oLPC1766_Blinky_Assembly.elf startup_lpc17xx.o blinky.o

This will produce the ARM executable file (LPC1766_Blinky_Assembly.elf) and also the map of the symbols (global / static variables location, function locations, etc) in ‘LPC1766_Blinky_Assembly.map’. Unfortunately, the executable itself is pretty useless, unless you have OS that can load the executable part from it. To load the executable part from the executable file and put it into Intel HEX file, use:

# arm-none-eabi-objcopy -j .flash -j .data_at_ram -O ihex LPC1766_Blinky_Assembly.elf LPC1766_Blinky_Assembly.hex

The thing that you’ll need to copy to your flash is: executable file (on .flash section) and init value for global/static variables (on .data_at_ram section).

The hex file contains the executable part that can be run by your MCU directly. Just download it using your favourite programmer (such as FlashMagic http://www.flashmagictool.com).

In Cortex-M3, there are 255 interrupt vectors, and it’s relocateable. During the initial boot, the interrupt vector table are located at 0×00, but, then, if you want to, you can move it to somewhere else.

The first ten interrupts are fixed by ARM (means you will always find them eventhough you’re using NXP, Atmel, STMicro, Luminary Micro, etc). The rest is up to the silicon vendors implementation.

The interrupt handler is a bit different from any other MCUs. You just need to write the interrupt handler address, without any additional code (such as: B <interrupt_handler_addr> to jump to specific address). Also, the first thing on your interrupt table is the stack address. The Cortex-M3 interrupt controller (NVIC) will need stack address before it can jump to the handler. Hence, it’s put as the first thing on the interrupt table.

Here’s how to implement it

/* Simple startup file for Cortex-M3 */

/* Thumb-2 instructions are only supported in unified syntax mode */
.syntax unified

/* Vector table definition */
.section “.cs3.interrupt_vector”
.long  __cs3_stack                 /* Top of Stack                 */
.long  Reset_Handler               /* Reset Handler                */
.long  NMI_Handler                 /* NMI Handler                  */
.long  HardFault_Handler           /* Hard Fault Handler           */
.long  MemManage_Handler           /* MPU Fault Handler            */
.long  BusFault_Handler            /* Bus Fault Handler            */
.long  UsageFault_Handler          /* Usage Fault Handler          */
.long  0                           /* Reserved                     */
.long  0                           /* Reserved                     */
.long  0                           /* Reserved                     */
.long  0                           /* Reserved                     */
.long  SVC_Handler                 /* SVCall Handler               */
.long  DebugMon_Handler            /* Debug Monitor Handler        */
.long  0                           /* Reserved                     */
.long  PendSV_Handler              /* PendSV Handler               */
.long  SysTick_Handler             /* SysTick Handler              */

/* Vendor specific interrupts
*  —- Not implemented
*/

/* Program section */
.section “.text”

/* Declare as thumb function. Otherwise it will not be linked
* correctly
*/
.thumb_func
/* Export the symbol so linker can see this */
.global Reset_Handler
Reset_Handler:
/* Jump to main(), a thumb function */
LDR     R0, =main
BX      R0
/* If main() ever exit, this should hold MCU from running wild */
B       .

/* This is how the lazy guy doing it: by aliasing all the
* interrupts into single address
*/
.thumb_func
NMI_Handler:
.thumb_func
HardFault_Handler:
.thumb_func
MemManage_Handler:
.thumb_func
BusFault_Handler:
.thumb_func
UsageFault_Handler:
.thumb_func
SVC_Handler:
.thumb_func
DebugMon_Handler:
.thumb_func
PendSV_Handler:
.thumb_func
SysTick_Handler:
B    . /* while(1); */

You don’t need to write your interrupt handler in assembly. Here’s simple way to write your Reset_Handler() in C:

/*
* Don’t forget to take out the Reset_Handler() on the startup file first
*/
extern int main(void);
void Reset_Handler(void) {
main();

// If main() ever exit, this should hold MCU from running wild
while(1);
}

But some people has found a way to code everything in C (instead of assembly and C) using callback function mechanism

/*
* startup_LPC1766.c – Startup file for LPC1766 Cortex-M3
*
* @author: kunilkuda_at_gmail_dot_com
*/
extern void __cs3_stack; ///< This is global variable from linker script

/* We gave ‘weak’ attribute, so these functions can be aliased into a single
* function
*/
void __attribute__((weak)) Reset_Handler(void);     /* Reset Handler */
void __attribute__((weak)) NMI_Handler(void);       /* NMI Handler */
void __attribute__((weak)) HardFault_Handler(void); /* Hard Fault Handler */
void __attribute__((weak)) MemManage_Handler(void); /* MPU Fault Handler */
void __attribute__((weak)) BusFault_Handler(void);  /* Bus Fault Handler */
void __attribute__((weak)) UsageFault_Handler(void);/* Usage Fault Handler */
void __attribute__((weak)) SVC_Handler(void);       /* SVCall Handler */
void __attribute__((weak)) DebugMon_Handler(void);  /* Debug Monitor Handler */
void __attribute__((weak)) PendSV_Handler(void);    /* PendSV Handler */
void __attribute__((weak)) SysTick_Handler(void);   /* SysTick Handler */

/*
* Ask GCC to put this array into .cs3.interrupt_vector section
*/
__attribute__ ((section(“.cs3.interrupt_vector”)))
void (* const g_pfnVectors[])(void) = {
&__cs3_stack,       // The initial stack pointer
Reset_Handler,      // The reset handler
NMI_Handler,        // The NMI handler
HardFault_Handler,  // The hard fault handler
MemManage_Handler,  // The MPU fault handler
BusFault_Handler,   // The bus fault handler
UsageFault_Handler, // The usage fault handler
0,                  // Reserved
0,                  // Reserved
0,                  // Reserved
0,                  // Reserved
SVC_Handler,        // SVCall handler
DebugMon_Handler,   // Debug monitor handler
0,                  // Reserved
PendSV_Handler,     // The PendSV handler
SysTick_Handler,    // The SysTick handler
};

/* Here’s how to alias multiple functions into single function
*/
void Default_Handler(void);
#pragma weak NMI_Handler        = Default_Handler /* NMI handler */
#pragma weak HardFault_Handler  = Default_Handler /* Hard Fault handler */
#pragma weak MemManage_Handler  = Default_Handler /* MPU Fault Handler */
#pragma weak BusFault_Handler   = Default_Handler /* Bus Fault Handler */
#pragma weak UsageFault_Handler = Default_Handler /* Usage Fault Handler */
#pragma weak SVC_Handler        = Default_Handler /* SVCall Handler */
#pragma weak DebugMon_Handler   = Default_Handler /* Debug Monitor Handler */
#pragma weak PendSV_Handler     = Default_Handler /* PendSV Handler */
#pragma weak SysTick_Handler    = Default_Handler /* SysTick Handler */

void Default_Handler(void) {
while (1);
}

extern int main(void);
void Reset_Handler(void) {
main();

// If main() ever exit, this should hold MCU from running wild
while(1);
}

For any method that you use, the most important part is defining your linker script to layout the code into the correct place.

/*
* Define the supported output formats – elf32-littlearm is the
*  default
*/  
OUTPUT_FORMAT(“elf32-littlearm”, “elf32-bigarm”, “elf32-littlearm”)   

/* Define the target architecture */  
OUTPUT_ARCH(arm)   

/* Define the system entry point */  
ENTRY(Reset_Handler)   

/* Define the memory layout for the board */
SECTIONS  
{  
/* LPC1766 flash is at 0×0000_0000 */
.flash 0×00000000 :
{
/* Tell the linker to collect any .cs3.interrupt_vector section to this
address */  
KEEP(*(.cs3.interrupt_vector));

/* Collect the executable parts here */
*(.text .text.*);
/* Collect the const variables here */
*(.rodata .rodata.*);

__sidata = .;
}

/*
* This section refers to variables with init value. The init values are
* stored on ROM, but addressed on RAM (otherwise the variables cannot be
* manipulated).
*
* This section will be loaded at 0×10000000, the start of LPC1766 RAM
*/
.data_at_ram 0×10000000: AT (LOADADDR(.flash) + SIZEOF(.flash))
{
__sdata = .;
*(.data .data.*);
__edata = .;
}

.ram :
{
__sbss = .;
/* Collect the global / static variables, without init value here */
*(.bss .bss.*);
__ebss = .;
}

/* Set __cs3_stack to point the end of memory
* This one depends on your MCU. I’m using LPC1766 with 256kB flash and
* 32kB RAM
*/  

__cs3_stack = 0×10000000 + (32 * 1024);
}

This is just an example that does nothing. For more complete demo, you can download the original source code from CMSIS website (http://www.onarm.com/download/download389.asp).

A friend of mine told me about simple rectifier configuration that’s usually deployed in white goods (iron, washing machine, vacuum cleaner, etc). You can view the explanation here and here. It’s very interesting to know that you actually don’t need a big transformer or even switching PSU to supply your MCU from AC source.

Here’s my schematic for my own board:

It will generate 5.1VDC at 21.12mA. Or at least that’s what I hope =)

Moving out to Singapore, I’ve become nearly disabled. No solder, no board, no multimeter, etc. Actually, my employer provides me with the tools, but I’m kinda hesitated to use it for my own personal use. I guess I have to buy it for my own later.

Anyway, since I’ve got nothing to do this Sunday, I’ve come up with quizzes, just to test my electronic insanity. What is the efficiency of these ugly linear PSUs ?

Simple Zener Rectifier

I’d say its efficiency is 17.59%..Here’s another one:

Current Feedback Linear Rectifier

My insanity said that it’s efficiency is 17.64%.

Is there anyone who has different answer than me ?

It seems like the FreeRTOS has some support to program a timeout, but unpublished anywhere. I’ve checked the FreeRTOS source code, regarding the usage, and it seems like it’s quite safe to use it under user’s application.

Here’s what I’ve found:

xTimeOutType x_timeout; //< Var to hold the current time
portTickType openTimeout; //< Var to hold the timeout

// Set the initial time, where timeout will be started
vTaskSetTimeOutState(&x_timeout);
// Set the timeout value
openTimeout = 512; //< In RTOS tick

// To check the timeout
if(xTaskCheckForTimeOut(&x_timeout, &openTimeout) == pdTRUE)
{
  // It’s timeout
} else {
  // It’s not timeout yet.
}

You can also combined the technique with do-while loop (see my previous post).

FreeRTOS is free open source RTOS that supports several architectures. You can get its source code here. This post is my port for my ATMega128 board. It may run on your board (or may not).My version is not much different from the original ATMega323 port. The things that I’ve changed are:

• Makefile: User can include it, rather than built their own Makefile.
• GCC flags: I added new CFLAGS and LDFLAGS to remove dead codes/unused functions. It’ll make your binaries smaller (and still works, I hope)
• Using RTC osc as RTOS’ tick interrupt: I need precise resolution for timing. Therefore, I moved the interrupt from OCR1A to asynchronous OCR0.

Here’s some explanation about the Makefile. I’ve added main Makefile in the FreeRTOS source code, so user that’s needed to build new code just need simple Makefile, like this:

SRC = leds.c
include $(FREERTOS_DIR)/Makefile

You can compile, program, generate COFF, SREC, IHEX as usual (because I’m using the standard AVR Makefile from mfile) as long as you define the FREERTOS_DIR, like this:

$ make FREERTOS_DIR=../FreeRTOS_ATMega128 program

Take a look at the main Makefile to know which Makefile variables that you can override.

The RTOS’ tick is changed to OCR0 interrupt. My board has RTC xtal (32.768kHz) attached on it. So, I’m expecting better timing precision than the original port. Anyway, this also means that you cannot use my FreeRTOS port without RTC xtal in your board.

The settings of the OCR0 enables the RTOS running with max 512Hz tick rate. Don’t try to use it more than 512Hz. It won’t tick (it will hang on OCR0 interrupt handler).

Anyway, for the curious minds, here’s my FreeRTOS port and my sample hello world.