microBuilder.eu

void cpuInit (void)

Initialises the system clocks to use the external crystal and run at 12MHz (12MHz x 1 = 12MHz).  This should be the first function called by your application, since the rest of the LPC1114 Code Base will not perform as expected if the CPU is in an 'unknown' state.  All pins are set to GPIO with the internal pull-up resistor enabled (to reduce power consumption by ensuring that no pins are left 'floating').

• None

#include "core/cpu/cpu.h"

int main(void)
{
  cpuInit();

  // Enter permanent loop
  while(1);
}

cpuDeviceID_t cpuGetDeviceID (void)

Get's the CPU part number from the CPU ID register

• None

cpuDeviceID_LPC1111, cpuDeviceID_LPC1112, cpuDeviceID_LPC1113, cpuDeviceID_LPC1114 or cpuDeviceID_Unknown

#include "core/cpu/cpu.h"

int main(void)
{
  cpuInit();

  cpuDeviceID_t id = cpuGetDeviceID();

  if (id == cpuDeviceID_LPC11114)
  {
    // Part is either LPC1114FBD48 or LPC1114FHN33
  }

  // Enter permanent loop
  while(1);
}

void adcInit (void)

Initialises the A/D converter and configures channels 0..3 for 10-bit, SW-controlled A/D conversion.

• None

uint32_t adcRead (uint8_t channelNum)

This function will manually start an A/D conversion on a single channel (0..7) and return the conversion results (0..1023).

• uint8_t channelNum: The A/D channel [0..7] that will be used during the A/D conversion.

0 if an overrun error occurred, otherwise a 10-bit value containing the A/D conversion results.

Only AD channels 0..3 are configured for A/D in adcInit. If you wish to use A/D pins 4..7 they will also need to be added to the adcInit function

#include "core/cpu/cpu.h"
#include "core/adc/adc.h"

void main (void)
{
  cpuInit();
  adcInit();

  uint32_t results = 0;  
  while(1)
  {
    // Get A/D conversion results from A/D channel 0
    results = adcRead(0);
  }
}

void gpioInit (void)

Initialises GPIO and enables the GPIO interrupt handler for all GPIO ports.

• None

void gpioSetDir (uint32_t portNum, uint32_t bitPos, gpioDirection_t dir)

Sets the direction (input/output) for a specific port pin.

• portNum: the gpio port number [0..3]
• bitPos: the bit position for the gpio pin [0..11]
• dir: the pin direction (gpioDirection_Input or gpioDirection_Output)

void gpioSetValue (uint32_t portNum, uint32_t bitPos, uint32_t bitVal)

Sets the value for a specific port pin (only relevant when a pin is configured as output).

• portNum: the gpio port number [0..3]
• bitPos: the bit position for the gpio pin [0..11]
• bitVal: indicates whether the pin should be set high (1) or low (0).

#include "core/cpu/cpu.h"
#include "core/gpio/gpio.h"

int main (void)
{
  cpuInit();
  gpioInit();

  // Set GPIO1.8 to output
  gpioSetDir(1, 8, gpioDirection_Output);
  // Disable the internal pullup/down resistor on P1.8
  gpioSetPullup(&IOCON_PIO1_8, gpioPullupMode_Inactive);
  // Set GPIO1.8 high
  gpioSetValue(1, 8, 1);

  while(1);
}

uint32_t gpioGetValue (uint32_t portNum, uint32_t bitPos)

Gets the value for a specific port pin.

• portNum: the gpio port number [0..3]
• bitPos: the bit position for the gpio pin [0..11]

1 if the pin is currently high, or 0 is the pin is currently low.

All GPIO pins on the LPC1114 have internal pull-up/pull-down resistors that can be individually configured. By default, the LPC1114 will enable the pull-up resistors on most pins when it comes out of reset. The rationale behind this decision is that placing the pins in a defined state will avoid wasting power when pins are left 'floating', but it can also cause some confusion if you are not explicitly setting the resistors to a different state yourself should this be required. In order to avoid problems, you should always explicitly set the state of the internal resistor using gpioSetPullup.

#include "core/cpu/cpu.h"
#include "core/gpio/gpio.h"

int main (void)
{
  cpuInit();
  gpioInit();

  // Set GPIO1.8 to input
  gpioSetDir(1, 8, gpioDirection_Input);
  // Disable the internal pullup/down resistor on P1.8
  gpioSetPullup (&IOCON_PIO1_8, gpioPullupMode_Inactive);

  uint32_t results = 0;
  while(1)
  {
    // Read the current state of GPIO1.8 (1 = high, 0 = low)
    results = gpioGetValue(1, 8);
  }
}

void gpioSetPullup (volatile uint32_t *ioconReg, gpioPullupMode_t mode)

All GPIO pins on the LPC1114 have internal pull-up/pull-down resistors that can be individually configured. This method can be used to explicitly set the internal resistor's 'mode' of operation. For details on the different modes (inactive, pull-up, pull-down, or repeater) see the LPC1114 User Manual.

• *ioconReg: pointer to the IOCON register for the appropriate pin (ex. 'IOCON_PIO1_8' for GPIO 1.8, 'IOCON_PIO2_2' for GPIO 2.2, etc.). Note: Since this is a pointer, you need to pass the 'address' of the register in to the method, and not it's value. This can be accomplished by placing a '&' just before the name of the IOCON register, for example: 'gpioSetPullup(&IOCON_PIO2_2, gpioPullupMode_Inactive);'.
• mode: the mode to set the internal resistor to (gpioPullupMode_Inactive, gpioPullupMode_PullDown, gpioPullupMode_PullUp or gpioPullupMode_Repeater).

By default, the LPC1114 will enable the pull-up resistors on most pins when it comes out of reset. The rationale behind this decision is that placing the pins in a defined state will avoid wasting power when pins are left 'floating', but it can also cause some confusion if you are not explicitly setting the resistors to a different state yourself should this be required. In order to avoid problems, you should always explicitly set the state of the internal resistor.

#include "core/cpu/cpu.h"
#include "core/gpio/gpio.h"

int main (void)
{
  cpuInit();
  gpioInit();

  // Set GPIO1.8, 1.9, 1.10 and 1.11 to input
  gpioSetDir(1, 8, gpioDirection_Input);
  gpioSetDir(1, 9, gpioDirection_Input);
  gpioSetDir(1, 10, gpioDirection_Input);
  gpioSetDir(1, 11, gpioDirection_Input);

  // Enable the pull-down resistor on P1.8
  gpioSetPullup (&IOCON_PIO1_8, gpioPullupMode_PullDown);
  // Enable the pull-up resistor on P1.9
  gpioSetPullup (&IOCON_PIO1_9, gpioPullupMode_PullUp);
  // Disable the internal resistor resistor on P1.10
  gpioSetPullup (&IOCON_PIO1_10, gpioPullupMode_Inactive);
  // Set P1.11 to 'Repeater' (remembers the last state explicitly set)
  gpioSetPullup (&IOCON_PIO1_11, gpioPullupMode_Repeater);

  while(1);
}

void gpioSetInterrupt (uint32_t portNum, uint32_t bitPos, gpioInterruptSense_t sense, gpioInterruptEdge_t edge, gpioInterruptEvent_t event)

Any GPIO pin on the LPC1114 can be configured as an external interrupt source. The gpioSetInterrupt method allows you to determine which pins act as an interrupt source, and specify the conditions under which an interrupt should be raised (if the pin goes high or low, etc.). Depending on the portNum specified, the interrupt will be handled (by default) by PIOINTx_IRQHandler, where 'x' is the port number in question (PIOINT1_IRQHandler would be entered if an interrupt was raised on GPIO pin 1.8, for example).

• portNum: the gpio port number [0..3]
• bitPos: the bit position for the gpio pin [0..11]
• sense: whether the interrupt should be configured as edge (gpioInterruptSense_Edge) or level (gpioInterruptSense_Level) sensitive.
• edge: whether an interrupt is triggered on one edge (gpioInterruptEdge_Single) or on both (gpioInterruptEdge_Double).
• event: whether the rising edge (gpioInterruptEvent_ActiveHigh) or the falling edge (gpioInterruptEvent_ActiveLow) should be used to trigger the interrupt. ActiveHigh means that a HIGH level on the pin will trigger an interrupt, ActiveLow means that a LOW level on the pin will trigger an interrupt.

#include "core/cpu/cpu.h"
#include "core/gpio/gpio.h"

int main (void)
{
    cpuInit();
    gpioInit();

    // Set GPIO1.8 to input
    gpioSetDir(1, 8, gpioDirection_Input);
    // Disable the internal pullup/down resistor on P1.8
    gpioSetPullup (&IOCON_PIO1_8, gpioPullupMode_Inactive);
    // Setup an interrupt on GPIO1.8
    gpioSetInterrupt(1,                               // Port
                     8,                               // Pin
                     gpioInterruptSense_Edge,         // Edge Sensitive
                     gpioInterruptEdge_Single,        // Single Edge
                     gpioInterruptEvent_ActiveHigh);  // Active High
    // Enable the interrupt
    gpioIntEnable(1, 8);

    while (1);
}

void gpioIntEnable (uint32_t portNum, uint32_t bitPos)

Enables an interrupt on the specified GPIO pin.

• portNum: the gpio port number [0..3]
• bitPos: the bit position for the gpio pin [0..11]

void gpioIntDisable (uint32_t portNum, uint32_t bitPos)

Disables an interrupt on the specified pin.

• portNum: the gpio port number [0..3]
• bitPos: the bit position for the gpio pin [0..11]

void gpioIntClear (uint32_t portNum, uint32_t bitPos)

Clears the interrupt on the specified pin. This method should only be called from withint the interrupt service routine (ISR) once the interrupt has been raise.

• portNum: the gpio port number [0..3]
• bitPos: the bit position for the gpio pin [0..11]

// IRQ Handler for GPIO Port 1
void PIOINT1_IRQHandler(void)
{
  uint32_t regVal;

  // Check if pin 1.8 raised the interrupt  
  regVal = gpioIntStatus(1, 8);
  if (regVal)
  {
    // Do Something
    ...
    // Clear the interrupt
    gpioIntClear(1, 8);
  }		
  return;
}

uint32_t gpioIntStatus (uint32_t portNum, uint32_t bitPos)

Gets the interrupt status for a specific port pin.

• portNum: the gpio port number [0..3]
• bitPos: the bit position for the gpio pin [0..11]

'1' if an interrupt was raised by the specified pin, otherwise '0'.

void pmuInit(void)

Initialises the power management unit, and configures pin 0.1 to act as a wakeup source from sleep or deep-sleep mode.

• None

For sleep and deep-sleep modes -- entered via pmuSleep and pmuDeepSleep-- any I/O pin can be used as a wakeup source. For deep power-down mode -- entered via pmuPowerDown -- only a low level on pin 1.4 (WAKEUP) can wake the device up.

By default, only P0.1 is configured as a wakeup source, but the appropriate code to enable any other pin as a wakeup source (from sleep or deep-sleep mode) is provided in pmuSleep and simply needs to be uncommented (the pin configured for GPIO may also need to be set to GPIO, following the example for P0.1).

void pmuSleep(void)

This function will put the device into sleep mode. Gpio pins 0.0..11 and 1.0 can be used to wake the device up (however, the pins must first be configured for this in pmuInit).

• None

#include "core/cpu/cpu.h"
#include "core/pmu/pmu.h"

int main(void)
{
    cpuInit();

    // Configure wakeup sources before going into sleep/deep-sleep.
    // By default, pin 0.1 is configured as wakeup source (falling edge)
    pmuInit();

    // Enter sleep mode
    pmuSleep();

    while(1)
    {
        // Wait for an interrupt to wake the device up
    }
}

void pmuDeepSleep( uint32_t sleepCtrl, uint32_t wakeupSeconds )

This function will put the device into deep-sleep mode. Any gpio pin can be used to wake the device up (however, the pins must first be configured for this in pmuInit). The sleepCtrl parameter is used to indicate which peripherals should be put in sleep mode (see the SCB_PDSLEEPCFG register for details). Optionally, providing a non-zero value to wakeupSeconds will cause the device to wakeup from deep-sleep after the specified delay using 32-bit timer 0 and pin 0.1 (CT32B0_MAT2).

Arguments

• sleepCtrl: The bits to set in the SCB_PDSLEEPCFG register. This controls which peripherals will be put in sleep mode.
• wakeupSeconds: If this is greater than 0, the device will be configure to wakeup from deep-sleep after the specified number of seconds.

#include "core/cpu/cpu.h"
#include "core/pmu/pmu.h"

int main(void)
{
    cpuInit();

    uint32_t pmuRegVal;

    // Configure wakeup sources before going into sleep/deep-sleep.
    // By default, pin 0.1 is configured as wakeup source (falling edge)
    pmuInit();

    // Inidicate which peripherals should be disabled in deep-sleep
    pmuRegVal = SCB_PDSLEEPCFG_IRCOUT_PD | 
                SCB_PDSLEEPCFG_IRC_PD | 
                SCB_PDSLEEPCFG_FLASH_PD | 
                SCB_PDSLEEPCFG_USBPLL_PD | 
                SCB_PDSLEEPCFG_SYSPLL_PD | 
                SCB_PDSLEEPCFG_SYSOSC_PD | 
                SCB_PDSLEEPCFG_ADC_PD | 
                SCB_PDSLEEPCFG_BOD_PD;

    // Enter deep sleep mode and wakeup after 10 seconds
    pmuDeepSleep(pmuRegVal, 10);

    while(1)
    {
    }
}

void pmuPowerDown( void )

This function will configure the PMU control register and enter deep power-down mode. Optionally, pre-determined values can be stored in the four general-purpose registers (PMU_GPREG0..3), which can be used to persist any essential system settings while the device is in deep power-down mode, so long as 3.3V is still available.

• None

The only way to wake a device up from deep power-down mode is to set a low-level on P1.4 (WAKEUP). If 3.3V power is lost, the values stored in the four general-purpose registers will also be lost.

#include "core/cpu/cpu.h"
#include "core/pmu/pmu.h"

int main(void)
{
    cpuInit();
    pmuInit();

    // Enter power-down mode
    pmuPowerDown();

    while(1)
    {
        // Device was woken up by WAKEUP pin
    }
}

void sspInit (uint32_t portNum, sspClockPolarity_t polarity, sspClockPhase_t phase)

Initialises the SSP port. By default, SSP is set to SPI frame-format with 8-bit data. Pin 2.11 is routed to serve as serial clock (SCK), and SSEL (0.2) is set to GPIO to allow manual control of when the SPI port is enabled or disabled. Overrun and timeout interrupts are both enabled.

• portNum: The port number.
• polarity: Indicates whether the clock should be held high (sspClockPolarity_High) or low (sspClockPolarity_Low) when inactive.
• phase: Indicates whether new bits start on the leading (sspClockPhase_RisingEdge) or falling (sspClockPhase_FallingEdge) edge of clock transitions

sspSelect() and sspDeselect() macros have been defined in ssp.h to control the SSEL line without having to know the specific pin being used.

void sspSend (uint32_t portNum, uint8_t *buf, uint32_t length)

Sends a block of data to the SSP port

• portNum: The port number.
• *buf: Pointer to the data buffer
• length: Block length of the data buffer

#include "core/cpu/cpu.h"
#include "core/ssp/ssp.h"

#define SSP_FIFOSIZE		8

int main(void)
{
    cpuInit();
    sspInit(0, sspClockPolarity_High, sspClockPhase_RisingEdge);

    uint8_t request[SSP_FIFOSIZE];
    uint8_t response[SSP_FIFOSIZE];

    // Send 0x9C to the slave device and wait for a response

    // Fill request buffer
    request[0] = 0x80 | 0x1C;

    // Enable CS line
    ssp0Select();

    // Send the 'request' data (1 byte)
    sspSend(0, (uint8_t *)&request, 1);

    // Wait for the response (1 byte)
    sspReceive(0, (uint8_t *)&response, 1);

    // Disable CS line
    ssp0Deselect();
}

void sspReceive(uint32_t portNum, uint8_t *buf, uint32_t length)

Receives a block of data from the SSP port

• portNum: The port number.
• *buf: Pointer to the data buffer
• length: Block length of the data buffer

void systickInit (uint32_t delayMs)

Initialises the systick timer with the specified delay in millaseconds (typical 10ms). This will cause a systick interrupt to be raised every x millaseconds, and an unsigned 32-bit variable named "msTicks" will be incremented by one every time the interrupt is fired.

• delayMs: Indicates the length of time in millaseconds between each system 'tick'.

void systickDelay (uint32_t delayTicks)

Causes a blocking delay for the specific number of systick timer ticks. The length of the delay depends on the value supplied to the systickInit function. The delay can be calculated by multiplying delayMs from systickInit with delayTicks. (For example, if the systick timer is configure for 10mS ticks, a delayTicks value of 15 would cause a 150mS delay.)

• delayTicks: The number of systick ticks to wait.

#include "core/cpu/cpu.h"
#include "core/systick/systick.h"

int main (void)
{
  // Initialise the cpu
  cpuInit();
  // Initialise the systick timer with one tick every 10 millaseconds
  systickInit(10);

  while(1)
  {
    // Wait 15 ticks on the systick timer (meaning 150ms)
    systickDelay(15);
    // Do something ...
  }
}

void timer16Init(uint8_t timerNum, uint16_t timerInterval)

Initialises a 16-bit timer with the supplied timer interval (the amount of time that passes between each timer 'tick'). Every time that this interval elapses, the timer's interrupt will be fired and the appropriate counter variable will be incremented by one (For example, with CT16B0, 'timer16_0_counter' would be incremented).

• timerNum: The 16-bit timer to initialise [0..1]
• timerInterval: The number of clock 'ticks' between resets [0..65534]

Care needs to be taken when configuring the timers since the pins are all multiplexed with other peripherals. This code is provided as a starting point, but it will need to be adjusted according to your own situation and pin/peripheral requirements

#include "/core/cpu/cpu.h"
#include "/core/timer16/timer16.h"

// Instantiated in timer16.c
extern volatile uint32_t timer16_0_counter;

int main(void)
{
    cpuInit();

    // Initialise timer0 with a delay of 0xFFFF, which will cause the
    // timer interrupt to fire every 65535 ticks and increment
    // timer16_0_counter by 1
    timer16Init(0, 0xFFFF);

    // Enable the timer
    timer16Enable(0);

    // At this point timer16_0_counter should start incrementing by 1
    // every 65535 ticks

    while(1)
    {
        // If the timer has been fired 10 times, disabled the timer
        if (timer16_0_counter == 10)
        {
            timer16Disable(0);
        }
    }
}

void timer16DelayTicks(uint8_t timerNum, uint16_t delayInTicks)

Causes a blocking delay for the specified number of clock ticks.

• timerNum: The 16-bit timer to use [0..1]
• delayInTicks: The number of clock ticks to delay [0..65534]

The exact duration of this delay depends on the speed of the system clock, but it will invariably be short because of the 16-bit limitation. For example, on a system with a 48MHz clock, a 1mS delay would be equal to 48,000 ticks, which is very close to the maximum 16-bit value of 65,535. Thus, the maximum delay measured in mS with a 48MHz clock is ~1.37mS.

#include "/core/cpu/cpu.h"
#include "/core/timer16/timer16.h"

int main(void)
{
    cpuInit();

    // Initialise timer 0 ... delay is provided but not used here
    timer16Init(0, 0xFFFF);

    // Enable the timer
    timer16Enable(0);

    while(1)
    {
        // Cause blocking delay for 6000 ticks (0.5mS @ 12MHz)
        // Note: The delay must be 65535 or less (16-bit value)
        timer16DelayTicks(0, 6000);
    }
}

void timer16DelayUS(uint8_t timerNum, uint16_t delayInUS)

Causes a blocking delay for the specified number of microseconds.

• timerNum: The 16-bit timer to use [0..1]
• delayInUS: The number of microseconds to wait

The maximum delay in uS will depend on the clock speed, but running at 12MHz the maximum delay (MR = 0xFFFF) would be 5461uS (0xFFFF / 12 = 5461.25), or 5.46 milliseconds.

#include "/core/cpu/cpu.h"
#include "/core/timer16/timer16.h"

int main(void)
{
    cpuInit();

    // Initialise timer 0 ... delay is provided but not used here
    timer16Init(0, 0xFFFF);

    // Enable the timer
    timer16Enable(0);

    while(1)
    {
        // Cause blocking delay for 500 microseconds (0.5mS)
        timer16DelayUS(0, 500);
    }
}

void timer16Enable(uint8_t timerNum)

Enables the specified timer (which will cause any configured interrupts to fire)

• timerNum: The 16-bit timer to enable [0..1]

void timer16Disable(uint8_t timerNum)

Disables the specified timer (which will stop any configured interrupts from firing)

• timerNum: The 16-bit timer to disable [0..1]

void timer16Reset(uint8_t timerNum)

Resets the specified timer.

• timerNum: The 16-bit timer to reset [0..1]

void timer32Init(uint8_t timerNum, uint32_t timerInterval)

Initialises a 32-bit timer with the supplied timer interval (the amount of time that passes between each timer 'tick'). Every time that this interval elapses, the timer's interrupt will be fired and the appropriate counter variable will be incremented by one (For example, with CT32B0, 'timer32_0_counter' would be incremented).

• timerNum: The 32-bit timer to initialise [0..1]
• timerInterval: The number of clock 'ticks' between resets [0..4,294,967,295]

Care needs to be taken when configuring the timers since the pins are all multiplexed with other peripherals. This code is provided as a starting point, but it will need to be adjusted according to your own situation and pin/peripheral requirements

#include "/core/cpu/cpu.h"
#include "/core/timer32/timer32.h"

// Instantiated in timer32.h
extern volatile uint32_t timer32_0_counter;

int main(void)
{
    cpuInit();

    // Initialise timer0 with a delay of 12000, which will cause the
    // timer interrupt to fire every 1mS @ 12MHz and increment
    // timer32_0_counter by 1
    timer32Init(0, 12000);

    // Enable the timer
    timer32Enable(0);

    // At this point timer32_0_counter should start incrementing by 1
    // every 12000 ticks

    while(1)
    {
        // If the timer has been fired 10 times, disabled the timer
        if (timer32_0_counter == 10)
        {
            timer32Disable(0);
        }
    }
}

void timer32Delay(uint8_t timerNum, uint32_t delay)

Causes a blocking delay for the specified number of 'ticks' on the timer. The duration of each tick is determined by the 'timerInterval' property supplied to timer32Init

• timerNum: The 32-bit timer to use [0..1]
• delay: The number of timer counter increments to wait

The maximum delay will depend on the the 'timerInterval' value supplied when initialising the timer (see timer32Init).

#include "/core/cpu/cpu.h"
#include "/core/timer32/timer32.h"

int main(void)
{
    cpuInit();

    // Initialise timer 0 with 1 millisecond 'ticks'
    timer32Init(0, TIMER32_CCLK_1MS);

    // Enable the timer
    timer32Enable(0);

    while(1)
    {
        // Cause a blocking delay for 1.5 seconds (1500 milliseconds)
        timer32Delay(0, TIMER32_DELAY_1MS * 1500);
    }
}

void timer32Enable(uint8_t timerNum)

Enables the specified timer (which will cause any configured interrupts to fire)

• timerNum: The 32-bit timer to enable [0..1]

void timer32Disable(uint8_t timerNum)

Disables the specified timer (which will stop any configured interrupts from firing)

• timerNum: The 32-bit timer to disable [0..1]

void timer32Reset(uint8_t timerNum)

Resets the specified timer.

• timerNum: The 32-bit timer to reset [0..1]

uart_pcb_t *uartGetPCB ()

Get a pointer to the UART's protocol control block, which can be used to check the UART status value, determine whether UART has already been initialised or not, determine if any outgoing data is waiting to be transmitted, and get a reference to the RX FIFO. 

• None

// Make sure that UART is initialised
uart_pcb_t *pcb = uartGetPCB();
if (!pcb->initialised)
{
  uartInit(CFG_UART_BAUDRATE);
}

void uartInit (uint32_t baudrate)

Initialises UART at the specified baud rate.

• baudRate: The baud rate to use when configuring the UART (ex. '57600').

#include "core/cpu/cpu.h"
#include "core/uart/uart.h"

#define UARTBUFFERSIZE 5

int main(void)
{
    cpuInit();
    uartInit(57600);

    uint8_t uartBuffer[UARTBUFFERSIZE] = { 'T', 'e', 's', 't', '\n' };

    while(1)
    {  
        // Constantly send contents of uartBuffer
        uartSend((uint8_t *)uartBuffer, UARTBUFFERSIZE);
    }
}

void uartSend (uint8_t *bufferPtr, uint32_t length)

Sends the contents of the buffer over UART.

• *bufferPtr: Pointer to the text buffer
• length: The size of the text buffer

void uartSendByte (uint8_t byte)

Sends a single byte over UART.

• byte: The byte to send

// Send 0xFF over UART
uartSendByte(0xFF);

// Send 'B' over UART (note single quotes)
uartSendByte('B');

void uartRxBufferInit ()

Initialises the RX FIFO buffer.

• None

uint8_t uartRxBufferRead ()

Read one byte out of the RX buffer. This function will return the byte located at the array index of the read pointer, and then increment the read pointer index. If the read pointer exceeds the maximum buffer size, it will roll over to zero.

• None

void uartRxBufferWrite(uint8_t data)

Write one byte into the RX buffer. This function will write one byte into the array index specified by the write pointer and increment the write index. If the write index exceeds the max buffer size, then it will roll over to zero.

Note: Normally you will not need to call this method yourself. All incoming data is handled by the UART ISR, and any bytes received via UART are automatically inserted in the RX buffer. You simply need to check for new messages at appropriate intervals by testing the return value of uartRxBufferDataPending() or looking at the value of "pcb->rxfifo.len" on the UART control block (which will be non-zero if data is present in the RX buffer).

• uint8_t data: The byte to add to the RX buffer.

#include "core/cpu/cpu.h"
#include "core/uart/uart.h"

int main(void)
{
    cpuInit();
    uartInit(57600);

    // Add 0xFF to the RX buffer
    uartRxBufferWrite(0xFF);

    // Check if the buffer is empty (it shouldn't be!)
    while (uartRxBufferDataPending())
    {
      // Retrieve the first available character in the buffer
      uint8_t c = uartRxBufferRead();
    }

    ...
}

void uartRxBufferClearFIFO ()

Clears the FIFO read and write pointers and sets the length to zero.

• None

void uartRxBufferDataPending()

Determines whether there is any data in the FIFO queue. If one or more bytes are present in the FIFO, this method will return 1. If the buffer is empty, it will return 0.

• None

void wdtInit (void)

Initialises the watchdog timer and sets up the interrupt (reset is not enabled by default).

• None

#include "core/cpu/cpu.h"
#include "core/wdt/wdt.h"

int main(void)
{
    cpuInit();
    wdtInit();

    // Pat the watchdog to start it
    wdtFeed();

    while(1)
    {
        // Keep the watchdog happy by regularly feeding it
        wdtFeed();

        // Any delay here > 250,000 ticks (~3.5mS @ 72MHz)
        // will cause the watchdog to raise an interrupt, which
        // will be handled by WDT_IRQHandler
    }
}

void wdtFeed (void)

Feeds the watchdog to keep it from timing out.

• None