event.h

Go to the documentation of this file.

/* Copyright 2014, Peter A. Bigot
 *
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 * * Redistributions of source code must retain the above copyright notice,
 *   this list of conditions and the following disclaimer.
 *
 * * Redistributions in binary form must reproduce the above copyright notice,
 *   this list of conditions and the following disclaimer in the documentation
 *   and/or other materials provided with the distribution.
 *
 * * Neither the name of the software nor the names of its contributors may be
 *   used to endorse or promote products derived from this software without
 *   specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */

#ifndef BSP430_UTILITY_EVENT_H
#define BSP430_UTILITY_EVENT_H

#include <bsp430/periph/timer.h>

typedef union uBSP430eventAnyType {
  char c;
  unsigned char uc;
  int i;
  unsigned int ui;
  long l;
  unsigned long ul;
  uint8_t u8;
  int8_t i8;
  uint16_t u16;
  int16_t i16;
  uint32_t u32;
  int32_t i32;
  size_t sz;
  void * p;
  void (* fp)();
} uBSP430eventAnyType;

typedef struct sBSP430eventTagConfig {
  const char * id;
  volatile unsigned int seqno;
} sBSP430eventTagConfig;

#if defined(BSP430_DOXYGEN) || ! defined(BSP430_EVENT_TAG_NUM_SUPPORTED)

#define BSP430_EVENT_TAG_NUM_SUPPORTED 8
#endif /* BSP430_EVENT_TAG_NUM_SUPPORTED */

#if defined(BSP430_DOXYGEN) || ! defined(BSP430_EVENT_RECORD_NUM_SUPPORTED)

#define BSP430_EVENT_RECORD_NUM_SUPPORTED 16
#endif /* BSP430_EVENT_RECORD_NUM_SUPPORTED */

static const unsigned char ucBSP430eventTag_LostEventRecord = 0;

static const unsigned int uiBSP430eventFlag_EventRecord = 0x01;

typedef struct sBSP430eventTagRecord {
  uBSP430eventAnyType u;

  unsigned long timestamp_utt;

  unsigned int seqno;

  unsigned char tag;

  unsigned char flags;
} sBSP430eventTagRecord;

/* Forward declaration */
struct sBSP430eventPeriodic;

typedef void (* vBSP430eventPeriodicProcess) (const sBSP430eventTagRecord * ep,
                                              struct sBSP430eventPeriodic * ap);

typedef struct sBSP430eventPeriodicConfig {
  sBSP430timerMuxAlarm alarm_;

  unsigned long interval_tck;

  unsigned char tag;

  unsigned char flags;
} sBSP430eventPeriodicConfig;

typedef sBSP430eventPeriodicConfig * hBSP430eventPeriodicConfig;

int iBSP430eventPeriodicAdd_ni (hBSP430timerMuxSharedAlarm shared,
                                hBSP430eventPeriodicConfig cfg,
                                unsigned long setting_tck);

int iBSP430eventPeriodicRemove_ni (hBSP430timerMuxSharedAlarm shared,
                                   hBSP430eventPeriodicConfig cfg);

/* Not public API: the number of tags currently allocated */
extern unsigned char nBSP430eventTagConfig_;
/* Not public API: the configuration data for all tags */
extern sBSP430eventTagConfig xBSP430eventTagConfig_[];
/* Not public API: the event flag state */
extern volatile unsigned int uiBSP430eventFlags_v_;
static BSP430_CORE_INLINE
const sBSP430eventTagConfig *
hBSP430eventTagLookup (unsigned char tag)
{
  if (tag < nBSP430eventTagConfig_) {
    return xBSP430eventTagConfig_ + tag;
  }
  return NULL;
}

unsigned char ucBSP430eventTagAllocate (const char * id);

unsigned int uiBSP430eventFlagAllocate ();

static BSP430_CORE_INLINE
int iBSP430eventFlagsEmpty_ni ()
{
  return !uiBSP430eventFlags_v_;
}

static BSP430_CORE_INLINE
int iBSP430eventFlagsEmpty ()
{
  int rv;
  BSP430_CORE_SAVED_INTERRUPT_STATE(istate);
  BSP430_CORE_DISABLE_INTERRUPT();
  do {
    rv = iBSP430eventFlagsEmpty_ni();
  } while (0);
  BSP430_CORE_RESTORE_INTERRUPT_STATE(istate);
  return rv;
}

static BSP430_CORE_INLINE
unsigned int uiBSP430eventFlagsGet_ni ()
{
  unsigned int rv = uiBSP430eventFlags_v_;
  uiBSP430eventFlags_v_ = 0;
  return rv;
}

static BSP430_CORE_INLINE
unsigned int uiBSP430eventFlagsGet ()
{
  unsigned int rv;
  BSP430_CORE_SAVED_INTERRUPT_STATE(istate);
  BSP430_CORE_DISABLE_INTERRUPT();
  do {
    rv = uiBSP430eventFlagsGet_ni();
  } while (0);
  BSP430_CORE_RESTORE_INTERRUPT_STATE(istate);
  return rv;
}

static BSP430_CORE_INLINE
void vBSP430eventFlagsSet_ni (unsigned int flags)
{
  uiBSP430eventFlags_v_ |= flags;
}

static BSP430_CORE_INLINE
void vBSP430eventFlagsSet (unsigned int flags)
{
  BSP430_CORE_SAVED_INTERRUPT_STATE(istate);
  BSP430_CORE_DISABLE_INTERRUPT();
  do {
    vBSP430eventFlagsSet_ni(flags);
  } while (0);
  BSP430_CORE_RESTORE_INTERRUPT_STATE(istate);
}

const volatile sBSP430eventTagRecord *
xBSP430eventRecordEvent_ni (unsigned char tag,
                            unsigned char flags,
                            const uBSP430eventAnyType * up);

static BSP430_CORE_INLINE
void vBSP430eventRecordEvent (unsigned char tag,
                              unsigned char flags,
                              const uBSP430eventAnyType * up)
{
  BSP430_CORE_SAVED_INTERRUPT_STATE(istate);
  BSP430_CORE_DISABLE_INTERRUPT();
  do {
    xBSP430eventRecordEvent_ni(tag, flags, up);
  } while (0);
  BSP430_CORE_RESTORE_INTERRUPT_STATE(istate);
}

int iBSP430eventTagGetRecords (sBSP430eventTagRecord * evts,
                               int len);

#endif /* BSP430_UTILITY_EVENT_H */