heartbeat.h

Go to the documentation of this file.

/* -*- mode: c; c-basic-offset: 4; -*- */
/* Created by Eric Crosson 2015-02-10
 * Note that this function looks gnarly with the #defines so the
 * client code doesn't. */
#ifndef __HEARTBEAT__
#define __HEARTBEAT__

/* Standard Libs */
#include <stdint.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>

/* TI Includes */
#include "inc/hw_ints.h"
#include "inc/hw_memmap.h"

/* Driverlib Includes */
#include "driverlib/debug.h"
#include "driverlib/fpu.h"
#include "driverlib/gpio.h"
#include "driverlib/interrupt.h"
#include "driverlib/pin_map.h"
#include "driverlib/sysctl.h"
#include "driverlib/timer.h"
#include "driverlib/rom.h"

#define HEART_RED GPIO_PIN_1
#define HEART_BLUE GPIO_PIN_2
#define HEART_GREEN GPIO_PIN_3

#define THORACIC_CAVITY GPIO_PORTF_BASE

/*--------------------------------------------------------------*
 * Begin non-modal API -- implicit subject is \HEART_BLUE.    *
 *--------------------------------------------------------------*/

inline
void heart_init() {

#if !(defined(PROFILING_DISABLE))
    /* Enable the GPIO port that is used for the on-board LED. */
    SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF);

    /* Enable the GPIO pins for the LED (PF2). */
    GPIOPinTypeGPIOOutput(THORACIC_CAVITY, HEART_BLUE);
#endif
}

inline
int32_t heart_status() {

#if !(defined(PROFILING_DISABLE))
    GPIOPinRead(THORACIC_CAVITY, HEART_BLUE);
#endif
}

inline
void heart_off() {

#if !(defined(PROFILING_DISABLE))
    GPIOPinWrite(THORACIC_CAVITY, HEART_BLUE, 0);
#endif
}

inline
void heart_on() {

#if !(defined(PROFILING_DISABLE))
    GPIOPinWrite(THORACIC_CAVITY, HEART_BLUE, 1);
#endif
}

inline
void heart_toggle() {

#if !(defined(PROFILING_DISABLE))
    GPIOPinWrite(THORACIC_CAVITY, HEART_BLUE, heart_status() ^ HEART_BLUE);
#endif
}

inline
void heart_beat() {

#if !(defined(PROFILING_DISABLE))
    GPIOPinWrite(THORACIC_CAVITY, HEART_BLUE, heart_status() ^ HEART_BLUE);
    GPIOPinWrite(THORACIC_CAVITY, HEART_BLUE, heart_status() ^ HEART_BLUE);
#endif
}

#define heart_wrap(x) \
    heart_beat();     \
    x                 \
    heart_toggle();   \

/*--------------------------------------------------------------*
 * Begin GPIO API -- concentrate on a muscle and pump it baby   *
 *   One day, this section desires to be fully modal            *
 *--------------------------------------------------------------*/

/* TODO: determine how to document the HEARTBEAT_MODAL switch in
 * Doxygen. */
#ifdef HEARTBEAT_MODAL

#include "../libos/os.h"

#define heart_wrap_(x) \
    heart_beat_();     \
    x                  \
    heart_toggle_();   \


#define heart_pump_(a, b) heart_init_(a, b)

typedef int32_t memory_address_t;

typedef struct muscle_t {
    memory_address_t base;
    memory_address_t pin;
} muscle_t;

static muscle_t HEART_MODAL_METADATA[SCHEDULER_MAX_THREADS];

inline
void heart_init_(memory_address_t base, memory_address_t pin) {

#if !(defined(PROFILING_DISABLE))
    /* Enable the GPIO port that is used for \HEART_ANCILLARY_MUSCLE. */
    switch(base) {
    case GPIO_PORTA_BASE: SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA); break;
    case GPIO_PORTB_BASE: SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOB); break;
    case GPIO_PORTC_BASE: SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOC); break;
    case GPIO_PORTD_BASE: SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOD); break;
    case GPIO_PORTE_BASE: SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOE); break;
    case GPIO_PORTF_BASE: SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF); break;
    case GPIO_PORTG_BASE: SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOG); break;
    case GPIO_PORTH_BASE: SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOH); break;
    case GPIO_PORTJ_BASE: SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOJ); break;
    }

    /* Enable the GPIO pins for \HEART_ANCILLARY_MUSCLE. */
    GPIOPinTypeGPIOOutput(base, pin);

    /* Save metadata allowing for modal use of this library */
    HEART_MODAL_METADATA[os_running_thread_id()].base = base;
    HEART_MODAL_METADATA[os_running_thread_id()].pin = pin;
#endif
}

inline
int32_t heart_status_modal(muscle_t* ancillary_muscle) {

#if !(defined(PROFILING_DISABLE))
    GPIOPinRead(ancillary_muscle->base, ancillary_muscle->pin);
#endif
}

inline
int32_t heart_status_() {

#if !(defined(PROFILING_DISABLE))
    heart_status_modal(&HEART_MODAL_METADATA[os_running_thread_id()]);
#endif
}

inline
void heart_off_modal(muscle_t* ancillary_muscle) {

#if !(defined(PROFILING_DISABLE))
    GPIOPinWrite(ancillary_muscle->base, ancillary_muscle->pin, 0);
#endif
}

inline
void heart_off_() {

#if !(defined(PROFILING_DISABLE))
    heart_off_modal(&HEART_MODAL_METADATA[os_running_thread_id()]);
#endif
}

inline
void heart_on_modal(muscle_t* ancillary_muscle) {

#if !(defined(PROFILING_DISABLE))
    GPIOPinWrite(ancillary_muscle->base, ancillary_muscle->pin, 1);
#endif
}

inline
void heart_on_() {

#if !(defined(PROFILING_DISABLE))
    heart_on_modal(&HEART_MODAL_METADATA[os_running_thread_id()]);
#endif
}

inline
void heart_toggle_modal(muscle_t* ancillary_muscle) {

#if !(defined(PROFILING_DISABLE))
    GPIOPinWrite(ancillary_muscle->base, ancillary_muscle->pin,
                 heart_status_(ancillary_muscle->base,
                               ancillary_muscle->pin) ^ ancillary_muscle->pin);
#endif
}

inline
void heart_toggle_() {

#if !(defined(PROFILING_DISABLE))
    heart_toggle_modal(&HEART_MODAL_METADATA[os_running_thread_id()]);
#endif
}

inline
void heart_beat_modal(muscle_t* ancillary_muscle) {

#if !(defined(PROFILING_DISABLE))
    GPIOPinWrite(ancillary_muscle->base, ancillary_muscle->pin,
                 heart_status_(ancillary_muscle->base,
                               ancillary_muscle->pin) ^ ancillary_muscle->pin);
    GPIOPinWrite(ancillary_muscle->base, ancillary_muscle->pin,
                 heart_status_(ancillary_muscle->base,
                               ancillary_muscle->pin) ^ ancillary_muscle->pin);
#endif
}

inline
void heart_beat_() {

#if !(defined(PROFILING_DISABLE))
    heart_beat_modal(&HEART_MODAL_METADATA[os_running_thread_id()]);
#endif
}

/*--------------------------------------------------------------*
 * End GPIO API                                                 *
 *--------------------------------------------------------------*/

#define heart_hew_muscle(a, b, c) \
    muscle_t a;                   \
    heart_hew_muscle_(&a, b, c)

inline
muscle_t* heart_hew_muscle_(muscle_t*        muscle,
                            memory_address_t base,
                            memory_address_t pin) {

#if !(defined(PROFILING_DISABLE))
    /* Initialize the muscle_t data structure */
    muscle->base = base;
    muscle->pin  = pin;
    /* Ensure this peripheral is initialized properly */
    heart_init_(base, pin);
    /* A convenience for the client developer */
    return muscle;
#endif
}
#endif /* HEARTBEAT_MODAL */

#endif