Types.h

Go to the documentation of this file.

#ifndef COSA_TYPES_H
#define COSA_TYPES_H

#include <avr/io.h>
#include <avr/sleep.h>
#include <avr/eeprom.h>
#include <avr/interrupt.h>
#include <avr/pgmspace.h>
#include <avr/sfr_defs.h>
#include <util/delay_basic.h>

#include <stdarg.h>
#include <stdint.h>
#include <stdlib.h>
#include <string.h>

#include "Cosa/Errno.h"
#include "Cosa/Board.hh"
#include "Cosa.h"

#define __UNIQUE(name) __CONCAT(name,__LINE__)

#define ROUND(x,y) (((x) + (y - 1)) / (y))

#define CHARBITS 8

#define BYTES(bits) ROUND(bits, CHARBITS)

#ifndef UINT8_MAX
# define UINT8_MAX ((uin8_t) 0xffU)
#endif
#ifndef UINT16_MAX
# define UINT16_MAX ((uint16_t) 0xffffU)
#endif
#ifndef UINT32_MAX
# define UINT32_MAX ((uint32_t) 0xffffffffUL)
#endif
#ifndef INT_MAX
# define INT_MIN INT16_MIN
# define INT_MAX INT16_MAX
#endif
#ifndef INT8_MAX
# define INT8_MIN ((int8_t) 0x80)
# define INT8_MAX ((int8_t) 0x7f)
#endif
#ifndef INT16_MAX
# define INT16_MIN ((int16_t) 0x8000)
# define INT16_MAX ((int16_t) 0x7fff)
#endif
#ifndef INT32_MAX
# define INT32_MIN ((int32_t) 0x80000000L)
# define INT32_MAX ((int32_t) 0x7fffffffL)
#endif
#ifndef INT_MAX
# define INT_MIN INT16_MIN
# define INT_MAX INT16_MAX
#endif

#ifndef NULL
# define NULL ((void*) 0)
#endif

typedef float float32_t;

union univ16_t {
  uint16_t as_uint16;
  int16_t as_int16;
  uint8_t as_uint8[2];
  int8_t as_int8[2];
  const void* as_ptr_P;
  void* as_ptr;
  struct {
    uint8_t low;
    uint8_t high;
  };
};
typedef univ16_t univ_t;

union univ32_t {
  float32_t as_float32;
  uint32_t as_uint32;
  int32_t as_int32;
  univ16_t as_univ16[2];
  uint16_t as_uint16[2];
  int16_t as_int16[2];
  uint8_t as_uint8[4];
  int8_t as_int8[4];
  const void* as_ptr_P[2];
  void* as_ptr[2];
  struct {
    uint16_t low;
    uint16_t high;
  };
};

#define LIKELY(x) __builtin_expect((x), true)
#define UNLIKELY(x) __builtin_expect((x), false)

#define UNUSED(x) (void) (x)

#define membersof(x) (sizeof(x) / sizeof(x[0]))

/*
 * Workaround for gcc offsetof macro usage and program memory data
 * warning in Arduino build with older version of AVR-GCC (1.0.5,
 * 1.5.6-r2 etc).
 */
#if ((__GNUC__ == 4) && (__GNUC_MINOR__ <= 3))
# undef offsetof
# define offsetof(t,m)                                                  \
  (__extension__(                                                       \
    {                                                                   \
      const t* __p = NULL;                                              \
      (size_t) &__p->m;                                                 \
    }                                                                   \
  ))
# define __PROGMEM  __attribute__((section(".progmem.data")))
#else
# define __PROGMEM PROGMEM
#endif

typedef const PROGMEM class prog_str* str_P;

#define STR_P(s)                                                        \
  (__extension__(                                                       \
    {                                                                   \
      static const char __c[] __PROGMEM = (s);                          \
      (str_P) &__c[0];                                                  \
    }                                                                   \
  ))
#undef PSTR
#define PSTR(s) STR_P(s)
#define __PSTR(s) STR_P(s)

inline char*
strcat_P(char* s1, str_P s2)
{
  return (strcat_P(s1, (const char*) s2));
}

inline str_P
strchr_P(str_P s, int __val)
{
  return ((str_P) strchr_P((const char*) s, __val));
}

inline str_P
strchrnul_P(str_P s, int __val)
{
  return ((str_P) strchrnul_P((const char*) s, __val));
}

inline int
strcmp_P(const char *s1, str_P s2)
{
  return (strcmp_P(s1, (const char*) s2));
}

inline int
strncmp_P(const char *s1, str_P s2, size_t n)
{
  return (strncmp_P(s1, (const char*) s2, n));
}

inline char*
strcpy_P(char* s1, str_P s2)
{
  return (strcpy_P(s1, (const char*) s2));
}

inline int
strcasecmp_P(const char *s1, str_P s2)
{
  return (strcasecmp_P(s1, (const char*) s2));
}

inline char*
strcasestr_P(const char *s1, str_P s2)
{
  return (strcasestr_P(s1, (const char*) s2));
}

inline size_t
strlen_P(str_P s)
{
  return (strlen_P((const char*) s));
}

typedef const PROGMEM void* void_P;
typedef const PROGMEM void_P void_vec_P;

/* Check if static_assert needs to be disabled */
#if (ARDUINO < 150)
# if !defined(__GXX_EXPERIMENTAL_CXX0X__)
#   define static_assert(condition,message)
# endif
#endif

#define I_CPU (F_CPU / 1000000L)

#define DELAY(us) _delay_loop_2((us) * (F_CPU / 4000000L))

extern void (*delay)(uint32_t ms);

extern void (*sleep)(uint16_t s);

extern void (*yield)();

#define nop() __asm__ __volatile__("nop")

#define barrier() __asm__ __volatile__("" ::: "memory")

inline uint8_t lock() __attribute__((always_inline));
inline uint8_t lock()
{
  uint8_t key = SREG;
  __asm__ __volatile__("cli" ::: "memory");
  return (key);
}

inline void unlock(uint8_t key) __attribute__((always_inline));
inline void unlock(uint8_t key)
{
  SREG = key;
  __asm__ __volatile__("" ::: "memory");
}

inline void __unlock(uint8_t* key) __attribute__((always_inline));
inline void __unlock(uint8_t* key)
{
  SREG = *key;
  __asm__ __volatile__("" ::: "memory");
}

#define synchronized                                                    \
  for (uint8_t __key __attribute__((__cleanup__(__unlock))) = lock(),   \
       i = 1; i != 0; i--)

typedef volatile bool condvar_t;

inline uint8_t lock(condvar_t &cond) __attribute__((always_inline));
inline uint8_t lock(condvar_t &cond)
{
  uint8_t key = lock();
  while (UNLIKELY(cond)) {
    unlock(key);
    yield();
    key = lock();
  }
  cond = true;
  return (key);
}

struct iovec_t {
  void* buf;                    
  size_t size;                  
  iovec_t(void* buf = NULL, size_t size = 0)
  {
    this->buf = buf;
    this->size = size;
  }
};

inline size_t iovec_size(const iovec_t* vec) __attribute__((always_inline));
inline size_t iovec_size(const iovec_t* vec)
{
  size_t len = 0;
  for (const iovec_t* vp = vec; vp->buf != NULL; vp++)
    len += vp->size;
  return (len);
}

inline void iovec_arg(iovec_t* &vp, const void* buf, size_t size)
  __attribute__((always_inline));
inline void iovec_arg(iovec_t* &vp, const void* buf, size_t size)
{
  vp->buf = (void*) buf;
  vp->size = size;
  vp++;
}

inline void iovec_end(iovec_t* &vp) __attribute__((always_inline));
inline void iovec_end(iovec_t* &vp)
{
  vp->buf = 0;
  vp->size = 0;
}

inline uint16_t swap(uint16_t value) __attribute__((always_inline));
inline uint16_t swap(uint16_t value)
{
  asm volatile("mov __tmp_reg__, %A0"   "\n\t"
               "mov %A0, %B0"           "\n\t"
               "mov %B0, __tmp_reg__"   "\n\t"
               : "=r" (value)
               : "0" (value)
               );
  return (value);
}

inline void swap(uint16_t* dest, const uint16_t* src, size_t size)
{
  if (UNLIKELY(size == 0)) return;
  do {
    *dest++ = swap(*src++);
  } while (--size);
}

template<class T>
void swap(T* dest, const T* src)
{
  swap((uint16_t*) dest, (const uint16_t*) src, sizeof(T) / sizeof(uint16_t));
}

inline void swap(uint16_t* buf, size_t size)
{
  if (UNLIKELY(size == 0)) return;
  do {
    int16_t data = *buf;
    *buf++ = swap(data);
  } while (--size);
}

template<class T>
void swap(T* buf)
{
  swap((uint16_t*) buf, sizeof(T) / sizeof(uint16_t));
}

inline int16_t swap(int16_t value) __attribute__((always_inline));
inline int16_t swap(int16_t value)
{
  return ((int16_t) swap((uint16_t) value));
}

inline void swap(int16_t* dest, const int16_t* src, size_t size)
{
  if (UNLIKELY(size == 0)) return;
  do {
    *dest++ = swap(*src++);
  } while (--size);
}

inline uint32_t swap(uint32_t value) __attribute__((always_inline));
inline uint32_t swap(uint32_t value)
{
  asm volatile("mov __tmp_reg__, %A0"   "\n\t"
               "mov %A0, %D0"           "\n\t"
               "mov %D0, __tmp_reg__"   "\n\t"
               "mov __tmp_reg__, %B0"   "\n\t"
               "mov %B0, %C0"           "\n\t"
               "mov %C0, __tmp_reg__"   "\n\t"
               : "=r" (value)
               : "0" (value)
               );
  return (value);
}

inline int32_t swap(int32_t value) __attribute__((always_inline));
inline int32_t swap(int32_t value)
{
  return ((int32_t) swap((uint32_t) value));
}

#define ntoh swap
#define hton swap

inline char tohex(uint8_t value) __attribute__((always_inline));
inline char tohex(uint8_t value)
{
  value &= 0xf;
  if (UNLIKELY(value > 9))
    return (value - 10 + 'a');
  return (value + '0');
}

inline char toHEX(uint8_t value) __attribute__((always_inline));
inline char toHEX(uint8_t value)
{
  value &= 0xf;
  if (UNLIKELY(value > 9))
    return (value - 10 + 'A');
  return (value + '0');
}

#endif