Hal/Hal.h

   1 /**
   2  * Hal.h -- HAL Interface Definitions
   3  *
   4  * This example HAL is intentionally simple.  The implementation is limited to:
   5  *
   6  * BUTTON -- a single button that when pressed will cause an interrupt.
   7  * DEBUG -- two debug GPIOs that are available as outputs from the EAP and under user control.
   8  * DELAY -- a delay routine that can delay by n milliseconds.
   9  * INIT -- set the hardware up to its initial state
  10  * LED -- a user LED that is available for application control.
  11  * TICK -- a timer that can be set to interrupt every n milliseconds
  12  * IDLE LOOP -- an event driven idle loop for controlling the EAP
  13  *
  14  * For information on Hal implementations for specific target hardware platforms,
  15  * visit the http://wiki.em-hub.com/display/ED.
  16  *
  17  **/
  18
  19 #ifndef Hal__H
  20 #define Hal__H
  21
  22 #include <stdint.h>
  23 #include <stdbool.h>
  24
  25 #ifdef __cplusplus
  26 extern "C" {
  27 #endif
  28
  29 extern int32_t buttonCnt;
  30
  31 typedef void (*Hal_Handler)(void);
  32
  33 /**
  34  * --------- Hal_buttonEnable ---------
  35  *
  36  * Enable the button interrupt and connect it to the user's buttonHandler
  37  *
  38  * When the button is pressed, it will cause an interrupt that will cause BUTTON event
  39  * to be entered into the event list.  Once dispatched by the idle loop, the user's
  40  * buttonHandler will be called.
  41  *
  42  * Inputs:
  43  *   buttonHandler - pointer to the user's handler to be called after interrupt
  44  *
  45  * Returns:
  46  *   None
  47  *
  48  * Side effects:
  49  *   BUTTON interrupt enabled
  50  *
  51  **/
  52 extern void Hal_buttonEnable(Hal_Handler handler);
  53 /**
  54  * --------- Hal_connected ---------
  55  *
  56  * Called whenever the MCM peripheral connects to a central.
  57  *
  58  * Could do other things associated with connection to the central.
  59  *
  60  * Inputs:
  61  *   None
  62  *
  63  * Returns:
  64  *   None
  65  *
  66  **/
  67 extern void Hal_connected(void);
  68 /**
  69  * --------- Hal_debugOff ---------
  70  *
  71  * Turns the selected DEBUG line off.
  72  *
  73  * The two DEBUG lines are output GPIOs that are available to the user for
  74  * debug purposes.
  75  *
  76  * Inputs:
  77  *   line - the index value of the debug line to turn off
  78  *
  79  * Returns:
  80  *   None
  81  *
  82  * Side Effects:
  83  *   DEBUG line off.
  84  *
  85  **/
  86 extern void Hal_debugOff(uint8_t line);
  87 /**
  88  * --------- Hal_debugOn ---------
  89  *
  90  * Turns the selected DEBUG line on.
  91  *
  92  * The two DEBUG lines are output GPIOs that are available to the user for
  93  * debug purposes.
  94  *
  95  * Inputs:
  96  *   line - the index value of the debug line to turn on
  97  *
  98  * Returns:
  99  *   None
 100  *
 101  * Side Effects:
 102  *   DEBUG line on.
 103  *
 104  **/
 105 extern void Hal_debugOn(uint8_t line);
 106 /**
 107  * --------- Hal_debugPulse ---------
 108  *
 109  * Emits a pulse on the selected DEBUG line.
 110  *
 111  * The two DEBUG lines are output GPIOs that are available to the user for
 112  * debug purposes.
 113  *
 114  * Inputs:
 115  *   line - the index value of the debug line to emit a pulse
 116  *
 117  * Returns:
 118  *   None
 119  *
 120  * Side Effects:
 121  *   DEBUG line turns on then off.
 122  *
 123  **/
 124 extern void Hal_debugPulse(uint8_t line);
 125 /**
 126  * --------- Hal_delay ---------
 127  *
 128  * Delays for the specified number of milliseconds.
 129  *
 130  * In this example, delay is done with CPU spinning for simplicity's sake.
 131  * This could easily use a timer interrupt for more power savings.
 132  *
 133  * Inputs:
 134  *   msecs - the number of milliseconds to delay
 135  *
 136  * Returns:
 137  *   None
 138  *
 139  * Side Effects:
 140  *   None
 141  *
 142  **/
 143 extern void Hal_delay(uint16_t msecs);
 144 /**
 145  * --------- Hal_disconnected ---------
 146  *
 147  * Called whenever the MCM peripheral disconnects from a central.
 148  *
 149  * Could do other things associated with connection to the central.
 150  *
 151  * Inputs:
 152  *   None
 153  *
 154  * Returns:
 155  *   None
 156  *
 157  **/
 158 extern void Hal_disconnected(void);
 159 /**
 160  * --------- Hal_idleLoop ---------
 161  *
 162  * The idle loop that controls EAP operations.
 163  *
 164  * The hal implements an event driven "idle loop" scheduler.
 165  * When there are no events pending, the idle loop sleeps.
 166  * When an event happens, the idle loop wakes up, and dispatches
 167  * to the appropriate event handler.
 168  *
 169  * The dispatching is done through a handlerTab that has one entry for each type of event.
 170  * Each handlerTab entry should be a handler of type hal_handler *.
 171  * There are currently three types of events, i.e. entries in the handlerTab:
 172  *   BUTTON_HANDLER_ID:    handler to call upon a button press
 173  *   TICK_HANDLER_ID:      handler to call upon a timer interrupt
 174  *   DISPATCH_HANDLER_ID:  handler to call upon a received message from the MCM
 175  *
 176  * Inputs:
 177  *   None
 178  *
 179  * Returns:
 180  *   None
 181  *
 182  * Side Effects:
 183  *   dispatches events as they come in
 184  *
 185  **/
 186 extern void Hal_idleLoop(void);
 187 /**
 188  * --------- Hal_init ---------
 189  *
 190  * Initialize the hardware
 191  *
 192  * Initializes the EAP and MCM into their reset state.  Should be called first.
 193  * Sets up the clock, ports, watchdog timer, etc.
 194  *
 195  *
 196  * Inputs:
 197  *   None
 198  *
 199  * Returns:
 200  *   None
 201  *
 202  * Side Effects:
 203  *   EAP and MCM in their initial state.
 204  *
 205  **/
 206 extern void Hal_init(void);
 207 /**
 208  * --------- Hal_ledOff ---------
 209  *
 210  * Turns the user LED off.
 211  *
 212  * Inputs:
 213  *   None
 214  *
 215  * Returns:
 216  *   None
 217  *
 218  * Side Effects:
 219  *   User LED off.
 220  *
 221  **/
 222 extern void Hal_greenLedOff(void);
 223 extern void Hal_redLedOff(void);
 224 /**
 225  * --------- Hal_ledOn ---------
 226  *
 227  * Turns the user LED on.
 228  *
 229  * Inputs:
 230  *   None
 231  *
 232  * Returns:
 233  *   None
 234  *
 235  * Side Effects:
 236  *   User LED on.
 237  *
 238  **/
 239 extern void Hal_greenLedOn(void);
 240 extern void Hal_redLedOn(void);
 241 /**
 242  * --------- Hal_ledRead ---------
 243  *
 244  * Returns the user LED state.
 245  *
 246  * Inputs:
 247  *   None
 248  *
 249  * Returns:
 250  *   Bool -  (true = user LED is on, false = user LED is off)
 251  *
 252  * Side Effects:
 253  *   None
 254  *
 255  **/
 256 extern bool Hal_greenLedRead(void);
 257 extern bool Hal_redLedRead(void);
 258 /**
 259  * --------- Hal_ledToggle ---------
 260  *
 261  * Toggles the user LED.
 262  *
 263  * Inputs:
 264  *   None
 265  *
 266  * Returns:
 267  *   None
 268  *
 269  * Side Effects:
 270  *   User LED toggles state.
 271  *
 272  **/
 273 extern void Hal_greenLedToggle(void);
 274 extern void Hal_redLedToggle(void);
 275 /**
 276  * --------- Hal_tickStart ---------
 277  *
 278  * Sets up the timer to interrupt every msecs milliseconds and the user's tickHandler
 279  * that will be called upon interrupt.
 280  *
 281  * Enable a timer interrupt every msecs ms.  The interrupt will cause a TICK event
 282  * to be entered into the event list.  Once dispatched by the idle loop, the user's
 283  * tickHandler will be called.
 284  *
 285  * Inputs:
 286  *   msecs - the number of milliseconds between tick interrupts
 287  *   tickHandler - the address of the user's tick handler that will be called
 288  *
 289  * Returns:
 290  *   None
 291  *
 292  * Side Effects:
 293  *   tickhandler called by the idle loop
 294  *
 295  **/
 296 extern void Hal_tickStart(uint16_t msecs, Hal_Handler Handler);
 297 extern void Hal_tickStop(void);
 298
 299 #ifdef __cplusplus
 300 }
 301 #endif
 302
 303 #endif /* Hal__H */