I bought a TinyRTC module on dx.com for a couple of euro.  It contains an at24c32 32k flash memory IC and a ds1307 real time clock IC.  The pictures below show how it was interfaced (via I2C) to an LPC1114FN28.  The LPC1114 was programmed using ISP/IAP over a USB to serial interface.  GCC 5.2.1 was used to compile code and LPC21ISP was used to download it.

 Top view of TinyRTC module on breadboard

 Bottom view of Tiny RTC on breadboard.

The code to drive all of this is available on this  github page

The code consists of the following modules:

init : This contains the interrupt vector table and a startup routine which initializes global and static variables, bumps the clock speed up to 48MHz and finally calls on main.

serial : This module manages the UART interface and is used extensively to output run time and debugging information

i2c : This module manages the I2C interface and is implemented as recommended in the LPC1114 reference manual .  The I2C interface is implemented as a state machine in hardware and takes a little getting used to.  If you enable debugging (uncomment the line #define DEBUG 1 at the start of the i2c.c file) the module outputs debug trace data showing all of the states visited by the I2C state machine.

ds1307: This manages the interface to the RTC and has set/get date routines.

at24c32: This manages the interface with the AT24C32 memory IC and contains functions to read and write random data (be careful of the 1 million write cycles).

main: This is the top level application which exchanges data with the DS1307 and AT24C32.

The DS1307 is capable of outputting a 1Hz square wave which may be used to wake a slumbering MCU from a power saving deep sleep.  Hopefully I will get around to this in a future post.

I’ve been struggling with this demonstrator of assembler on the LPC1114 for a while but finally cracked it (on a train ride across the country :). Hope this is instructive to somebody. I think I have stripped the assembler directives down as much as possible, if you find a mistake please comment below.

// Minimal assembler blinky example for LPC1114FN28
// This program flashes an LED on and off.  It is used as a 
// demonstrator for class work
// LED is on GPIO0 bit 2
		.syntax unified
		.cpu cortex-m0	// Which variant we are using
		.thumb  /* Cortex micros only understand thumb(2) code	*/
		.global Vector_Table, start	
/* Set up interrupt vector table */
		.text
/* It would seem that the LPC1114FN28 treats the area of flash used by
the first 16 vectors as special.  If you attempt to place code here
it doesn't work so you must either skip past this space or just place
dummy values here */
Vector_Table:    
	.word     0x10001000 	/* Top of Stack */
    .word     start     	/* Reset Handler */
    .word 	  0		/* NMI */
	.word 	  0		/* Hard Fault */
	.word 	  0     	/* Reserved */
	.word 	  0     	/* Reserved */
	.word 	  0   	    	/* Reserved */
	.word 	  0  	     	/* Reserved */
	.word 	  0   	     	/* Reserved */
	.word 	  0  	      	/* Reserved */
	.word 	  0   	     	/* Reserved */
	.word 	  0		/* SVC */
	.word 	  0    	    	/* Reserved */
	.word 	  0     	/* Reserved */
	.word 	  0 		/* PendSV */
	.word 	  0 		/* SysTick */	
    
   
/* the program starts here */	
	.thumb_func		// The LSB of the address of thumb instructions is 
				// required to be 1 - the LSB is used as a flag to 
				// indicate thumb instructions are being used.
				// The Cortex M series of processors only understand
				// thumb instructions so if PC is loaded with an
				// address with LSB = 0 then this is treated as an
				// an illegal instruction 
				// the .thumb_func directive forces the LSB of
				// 'start' to be 1

start:
// Do initial IO configuration
// Turn on the clocks for GPIO and IOCON
		ldr R1,SYSAHBCLKCTRL	// make pointer to register		
		ldr R0,[R1]		// read current value
		ldr R2,SYSAHBCLKMASK	// read desired bit pattern
		orrs R0,R0,R2		// combine with register contents
		str R0,[R1]		// write back to register
// Make sure pin 25 behaves as a GPIO
		ldr R1,IOCON_PIO0_2	// make pointer to register
		ldr R0,[R1]		// read current value
		ldr R2,IOCONMASK	// read desired bit pattern
		bics R0,R0,R2		// combine with register contents
		str R0,[R1]		// write back to register
// Make pin 25 behave as an output
		ldr R1,GPIO0DIR		// make pointer to register
		ldr R0,[R1]		// read current value
		ldr R2,GPIO0MASK	// read desired bit pattern
		orrs R0,R0,R2		// combine with register contents
		str R0,[R1]		// write back to register
		
// Now enter the main loop
main_loop:
// Set bit 2
		ldr R1,GPIO0DATA	// make pointer to port data register
		ldr R0,[R1]		// read current value
		ldr R2,GPIO0MASK	// read bit pattern
		orrs R0,R0,R2		// set bits
		str R0,[R1]		// write new value		
		
		bl delay		// Leave the LED on for a while

// clear bit 2
		ldr R1,GPIO0DATA	// make pointer to port data register
		ldr R0,[R1]		// read current value
		ldr R2,GPIO0MASK	// read mask
		bics R0,R0,R2		// clear bits
		str R0,[R1]		// write new value
		
		bl delay		// Leave the LED on for a while
		
		b	main_loop	/* branch back to start of loop */

delay:	ldr R3,DELAYLENGTH
delay_loop:
		subs R3,R3,#1
		bne delay_loop
		bx LR
// Constants go below here		
		.align 2		/* Must force realignment again here */
GPIO0DATA: 	.word 	0x50003ffc
GPIO0DIR: 	.word 	0x50008000
SYSAHBCLKCTRL: 	.word	0x40048080
IOCON_PIO0_2:	.word 	0x4004401c
SYSAHBCLKMASK:	.word   0x10040
IOCONMASK:	.word   0x3
GPIO0MASK:	.word 	0x04
NOTGPIO0MASK:	.word 	0xfffffffb
DELAYLENGTH:	.word 	0xfffff

The Linker script file is as follows:

MEMORY
{
    flash : org = 0x00000000, len = 32k
    ram : org = 0x10000000, len = 4k
}
  
SECTIONS
{
        
	. = ORIGIN(flash);
        .text : {
		  *(.vectors); /* The interrupt vectors */
		  *(.text);
        } >flash
	. = ORIGIN(ram);
        .data : {
	  INIT_DATA_VALUES = LOADADDR(.data);
	  INIT_DATA_START = .;
	    *(.data);
	  INIT_DATA_END = .;
        } >ram AT>flash
	BSS_START = .;
	.bss : {
	  
	    *(.bss);
	  
	} > ram
	BSS_END = .;
}

And finally the makefile is

# Specify the compiler to use
CC=arm-none-eabi-gcc
# Specify the assembler to use
AS=arm-none-eabi-as
# Specity the linker to use
LD=arm-none-eabi-ld

CCFLAGS=-mcpu=cortex-m0 -mthumb -g 
ASFLAGS=-mcpu=cortex-m0 -mthumb -g --warn
# List the object files involved in this project
OBJS=	blinky.o 
blinky.elf : $(OBJS)
	$(LD) $(OBJS) -T linker_script.ld --cref -Map blinky.map -nostartfiles -o main.elf
	 objcopy -O ihex main.elf main.hex
blinky.o: blinky.s	
	$(AS) $(ASFLAGS) blinky.s -asghl=blinky.lst -o blinky.o
# if someone types in 'make clean' then remove all object files and executables
# associated wit this project
clean: 
	rm $(OBJS) 
	rm blinky.elf 

I’ve been experimenting with git and github and decided to upload a version of LPC21ISP that is patched for the LPC824 (see an earlier post).  It can be found at this link:

LPC21ISP with LPC824 support

ARM have developed a range of optimized DSP functions for all of the Cortex MCU’s. I have found them a challenge to use in “baremetal” gcc based projects as they rely on a particular directory structure and certain compiler directives. The project linked below tackles these difficulties and implements a real-time Finite Impulse Response FIR low pass filter on an STM32F303 Nucleo board.  The filter has a sample rate of 20kHz and a cut-off frequency of 1kHz.  Initial evaluations indicate the filter performs well and further experimentation will definitely follow.

The output voltage at 500Hz is shown in yellow below (input signal is green trace).

The output voltage at 1kHz is shown in yellow below.  The roll off is a little more than expected but this could be the result of truncating of coefficients.

Code and further explanatory documentation is available here:

http://eleceng.dit.ie/frank/arm/BareMetalSTM32F303Nucleo/fir/

Following earlier posts about the STM32F042 nucleo boards I’ve decided to investigate the more powerful STM32F303 Nucleo board.  This has a similar layout to the Arduino nano but includes an ARM Cortex M4F device with ADC’s and a DAC.  I’ve begun posting projects here:

http://eleceng.dit.ie/frank/arm/BareMetalSTM32F303Nucleo/index.html

Using high speed PWM it is possible to generate an acceptable audio output from an LPC1114. The circuit above samples the audio input and drives an output speaker using PWM.  The PWM and sampling frequency are both set to 48MHz/1024 or 46875Hz and resolution is 10bits.  More details can be found here:

http://eleceng.dit.ie/frank/arm/BareMetalLPC1114/analogio/index.html