X-Git-Url: https://codewiz.org/gitweb?a=blobdiff_plain;f=bertos%2Fcfg%2Fmacros.h;h=6c9b63ef0001b0877a0086a162f83b312cc7f10d;hb=d30e8cd8d67361277fd8e98dc47417ae2435bc9b;hp=caa2340f4792bedae0214eabbeb94b3bd73bea68;hpb=cba26286807ebe6b31c31d165677271de0417def;p=bertos.git

diff --git a/bertos/cfg/macros.h b/bertos/cfg/macros.h
index caa2340f..6c9b63ef 100644
--- a/bertos/cfg/macros.h
+++ b/bertos/cfg/macros.h
@@ -30,9 +30,12 @@
  *
  * -->
  *
+ * \defgroup macros General purpose macros
+ * \ingroup core
+ * \{
+ *
  * \brief Common and handy function macros
  *
- * \version $Id$
  * \author Bernie Innocenti <bernie@codewiz.org>
  * \author Giovanni Bajo <rasky@develer.com>
  */
@@ -95,6 +98,11 @@
 	#define MAX(a,b)	(((a) > (b)) ? (a) : (b))
 #endif /* !(COMPILER_STATEMENT_EXPRESSIONS && COMPILER_TYPEOF) */
 
+/** Align \p value to the next \p align boundary */
+#define ALIGN_UP(value, align)	(((value) & ((align) - 1)) ? \
+				(((value) + ((align) - 1)) & ~((align) - 1)) : \
+				(value))
+
 /** Bound \a x between \a min and \a max. */
 #define MINMAX(min,x,max)  (MIN(MAX(min, x), max))
 
@@ -184,11 +192,46 @@
 
 /**
  * Perform an integer division rounding the result to the upper int value.
- * \note \a divisor should preferibly be a costant, otherwise this macro generates
- * 2 division. Also divisor is evaluated twice.
+ * \note \a divisor is evaluated twice.
  */
 #define DIV_ROUNDUP(dividend, divisor)  (((dividend) + (divisor) - 1) / (divisor))
 
+
+/**
+ * Perform a multiply between the integer \a a and the float constant \a f.
+ *
+ * This macro can be used in order to avoid floating point arithmetics
+ * in expressions like this:
+ * \code
+ * int a, b;
+ * a = b * 0.5579652750;
+ * \endcode
+ *
+ * This macro rounds the floating point constant to a fraction,
+ * usign (2 ^ prec) as the denominator.
+ * For instance, with prec = 8, the constant 0.5579652750 will be rounded to:
+ * (143 / 256) = 0.55859375
+ * So, the former code will be transformed to:
+ * \code
+ * a = b * 143 / 256;
+ * \endcode
+ *
+ * Since the denominator is a power of 2, we rely on the compiler to optimize
+ * this to a right shift.
+ * So, when you have to multiply an integer by a float constant, this macro
+ * will not use the floating point arithmentics.
+ * The operation will be converted to a mul + shift, with a huge performance boost.
+ *
+ * \note \a f MUST be a constant in order gain performance benefits.
+ *
+ * \param a integer you want to multiply
+ * \param f floating point constant which you want to multply with \a a
+ * \param prec conversion precision, ranges from 1 to the number of bits in a long.
+ *             The higher, the better the approximation of the float constant will be.
+ */
+#define INT_MULT(a, f, prec) (((a) * (long)((f) * (1 << (prec)) + 0.5)) >> (prec))
+
+
 /** Round up \a x to an even multiple of the 2's power \a pad. */
 #define ROUND_UP2(x, pad) (((x) + ((pad) - 1)) & ~((pad) - 1))
 
@@ -355,5 +398,50 @@
  */
 typedef uint32_t id_t;
 
+/**
+ * Check if a pointer is aligned to a certain power-of-2 size
+ */
+INLINE bool is_aligned(const void *addr, size_t size)
+{
+	return ((size_t)addr & (size - 1)) == 0;
+}
+
+/**
+ * Convert one 32bit bcd numbert to int.
+ */
+#define BCD_TO_INT_32BIT(bcd)  \
+	((uint32_t )((bcd) & 0xf) * 1 +  \
+	(((bcd) >> 4) & 0xf)  * 10 +      \
+	(((bcd) >> 8) & 0xf)  * 100 +     \
+	(((bcd) >> 12) & 0xf) * 1000 +   \
+	(((bcd) >> 16) & 0xf) * 10000 +   \
+	(((bcd) >> 20) & 0xf) * 100000 +  \
+	(((bcd) >> 24) & 0xf) * 1000000 + \
+	(((bcd) >> 28) & 0xf) * 10000000) \
+
+/**
+ * Extract chunk of bit from gived array (uint32_t type).
+ * \param resp array of bit 32bit aligned
+ * \param start bit position in array
+ * \param size of bit chuck from start
+ * \return uint32_t chunk value.
+ */
+#define UNSTUFF_BITS(resp, start, size)                   \
+    ({                              \
+        const uint32_t __size = size;                \
+        const uint32_t __mask = (__size < 32 ? 1 << __size : 0) - 1; \
+        const uint32_t __off = 3 - ((start) / 32);           \
+        const uint32_t __shft = (start) & 31;            \
+        uint32_t __res;                      \
+                                    \
+        __res = resp[__off] >> __shft;              \
+        if (__size + __shft > 32)               \
+            __res |= resp[__off-1] << ((32 - __shft) % 32); \
+        __res & __mask;                     \
+    })
+
+
+/** \} */ //defgroup macros
+
 #endif /* MACROS_H */