Jason Garner / registers

my implementation of mbed-like classes using the LPC1768 register access.

Dependents:   registers-example RedWireBridge

This is just to satisfy my curiosity on how the mbed libraries work. I put it here just in case others are too. Every time I learn how another internal register works, I'll keep it here to save myself from future coding headaches.

working

  • DigitalIn
  • DigitalOut
  • wait()

mostly working

  • Serial
  • Timer
  • Ticker
  • Timeout

Serial doesn't have all the methods that mbed had, but it works for me. (only UART0, so only over USB to the pc for now) Timer has the same limitations of mbed for default resolution (30 min limit), and if you start at the end of resolution and stop after it rolls back to 0, it doesn't take that into account. But I added the option to change resolution, so I can have longer timers.

For Ticker, I used a 100 microsecond timer instead of a 1 microsecond Timer, so the smallest interval in between function calls is 100 microseconds. (10KHz) However, this means that the maximum interval in between function calls is 59 hours. (untested)

The Timeout class, simply uses a Ticker, but then marks it as nonactive after the first function call. Automatically calls the detach() function when attaching it again, so no don't need to worry about it.

Ticker.h

Committer:
elevatorguy
Date:
2013-01-03
Revision:
2:276fb0fe230c
Parent:
0:d2d9baa1a6d8

File content as of revision 2:276fb0fe230c:

#ifndef __TICKER_H_
#define __TICKER_H_

#include "LPC17xx.h"
//#include "cmsis_nvic.h"
//old way: NVIC_SetVector(TIMER2_IRQn, funcaddr); //tell it to run this function


/**
 * @author Jason Garner
 *
 * <b>Ticker</b> is an alternative implementation of the Mbed library <a href="/handbook/Ticker">Ticker</a> to save memory.
 * The maximum number of Ticker instances is fully customizable. 
 *
 */
class Ticker
{
    void initTimer2(); // the constructor initializes the hardware timer, if it wasn't already initialized
public:
    static bool timer2initialized; //stores whether the timer has been initialized
    static Ticker** tickers; //array of pointers to ticker instances
    uint32_t func; //function that NVIC will call on interrupts
    uint32_t interval; // unit interval to execute func (unit = 100 microseconds)
    uint32_t remaining; // units remaning until executing func (unit = 100 microseconds)
    static int active_tickers; //how many instances of this class we have that are attached. (NVIC needs this)
    static int MAX; // max size of Ticker* array
    bool active; // whether or not the instance is an active Ticker 
    bool timeout; // if set to true, this is effectively a Timeout object now. (it detaches after the next function call)
     /**
     * Regular constructor: the default internal array size is 5.
     */  
    Ticker();

     /**
     * Custom constructor: initializes the object with the specified parameter.
     *
     * @param max Maximum instances of Ticker objects allowed. (sets internal array size of Ticker* to instances)
     */  
    Ticker(int);
    
    ~Ticker(); //DESTRUCTOR   
    
     /**
     * Attach a function to be called by the Ticker, specifiying the interval in seconds. 
     * The timer is a 32bit 100 microsecond Timer, so the smallest time is 100 microseconds and the largest time is about 59 hours. 
     *
     * @param fptr pointer to the function to be called 
     * @param t The time in seconds in between function calls.
     */  
    void attach(void (*fptr)(void), float t); //address of function to call, and interval to call it
    
     /**
     * Detaches the function from the Ticker. The function will no longer be called, and a new one can now be attached.
     */  
    void detach(); //removes address from ticker array
};

#endif