daisy_core.h

Go to the documentation of this file.

#pragma once
#ifndef DSY_CORE_HW_H
#define DSY_CORE_HW_H 
#include <stdint.h>
#include <stdlib.h>
 
#if defined(_MSC_VER)
#define FORCE_INLINE __forceinline 
#elif defined(__clang__)
#define FORCE_INLINE inline __attribute__((always_inline)) 
#pragma clang diagnostic ignored "-Wduplicate-decl-specifier"
#elif defined(__GNUC__)
#define FORCE_INLINE inline __attribute__((always_inline)) 
#else
#error unknown compiler
#endif
 
#define DMA_BUFFER_MEM_SECTION __attribute__((section(".sram1_bss")))
#define DTCM_MEM_SECTION __attribute__((section(".dtcmram_bss")))
 
#define FBIPMAX 0.999985f             
#define FBIPMIN (-FBIPMAX)            
#define U82F_SCALE 0.0078740f         
#define F2U8_SCALE 127.0f             
#define S82F_SCALE 0.0078125f         
#define F2S8_SCALE 127.0f             
#define S162F_SCALE 3.0517578125e-05f 
#define F2S16_SCALE 32767.0f          
#define F2S24_SCALE 8388608.0f        
#define S242F_SCALE 1.192092896e-07f  
#define S24SIGN 0x800000              
#define S322F_SCALE 4.6566129e-10f    
#define F2S32_SCALE 2147483647.f      
#define OUT_L out[0]
 
#define OUT_R out[1]
 
#define IN_L in[0]
 
#define IN_R in[1]
 
FORCE_INLINE float cube(float x)
{
    return (x * x) * x;
}
 
FORCE_INLINE float u82f(uint8_t x)
{
    return ((float)x - 127.f) * U82F_SCALE;
}
 
FORCE_INLINE uint8_t f2u8(float x)
{
    x = x <= FBIPMIN ? FBIPMIN : x;
    x = x >= FBIPMAX ? FBIPMAX : x;
    return (uint8_t)((x * F2U8_SCALE) + F2U8_SCALE);
}
 
 
FORCE_INLINE float s82f(int8_t x)
{
    return (float)x * S82F_SCALE;
}
 
FORCE_INLINE int8_t f2s8(float x)
{
    x = x <= FBIPMIN ? FBIPMIN : x;
    x = x >= FBIPMAX ? FBIPMAX : x;
    return (int32_t)(x * F2S8_SCALE);
}
 
FORCE_INLINE float s162f(int16_t x)
{
    return (float)x * S162F_SCALE;
}
 
FORCE_INLINE int16_t f2s16(float x)
{
    x = x <= FBIPMIN ? FBIPMIN : x;
    x = x >= FBIPMAX ? FBIPMAX : x;
    return (int32_t)(x * F2S16_SCALE);
}
 
FORCE_INLINE float s242f(int32_t x)
{
    x = (x ^ S24SIGN) - S24SIGN; //sign extend aka ((x<<8)>>8)
    return (float)x * S242F_SCALE;
}
FORCE_INLINE int32_t f2s24(float x)
{
    x = x <= FBIPMIN ? FBIPMIN : x;
    x = x >= FBIPMAX ? FBIPMAX : x;
    return (int32_t)(x * F2S24_SCALE);
}
 
FORCE_INLINE float s322f(int32_t x)
{
    return (float)x * S322F_SCALE;
}
FORCE_INLINE int32_t f2s32(float x)
{
    x = x <= FBIPMIN ? FBIPMIN : x;
    x = x >= FBIPMAX ? FBIPMAX : x;
    return (int32_t)(x * F2S32_SCALE);
}
 
 
typedef enum
{
    DSY_GPIOA, 
    DSY_GPIOB, 
    DSY_GPIOC, 
    DSY_GPIOD, 
    DSY_GPIOE, 
    DSY_GPIOF, 
    DSY_GPIOG, 
    DSY_GPIOH, 
    DSY_GPIOI, 
    DSY_GPIOJ, 
    DSY_GPIOK, 
    DSY_GPIOX, 
    DSY_GPIO_LAST, 
} dsy_gpio_port;
 
typedef struct
{
    dsy_gpio_port port; 
    uint8_t       pin;  
} dsy_gpio_pin;
 
FORCE_INLINE dsy_gpio_pin dsy_pin(dsy_gpio_port port, uint8_t pin)
{
    dsy_gpio_pin p;
    p.port = port;
    p.pin  = pin;
    return p;
}
 
FORCE_INLINE uint8_t dsy_pin_cmp(dsy_gpio_pin *a, dsy_gpio_pin *b)
{
    return ((a->port == b->port) && (a->pin == b->pin));
}
 
#ifdef __cplusplus
 
namespace daisy
{
enum GPIOPort
{
    PORTA, 
    PORTB, 
    PORTC, 
    PORTD, 
    PORTE, 
    PORTF, 
    PORTG, 
    PORTH, 
    PORTI, 
    PORTJ, 
    PORTK, 
    PORTX, 
};
 
struct Pin
{
    GPIOPort port;
    uint8_t  pin;
 
    constexpr Pin(const GPIOPort pt, const uint8_t pn) : port(pt), pin(pn) {}
 
    constexpr Pin() : port(PORTX), pin(255) {}
 
    constexpr bool IsValid() const { return port != PORTX && pin < 16; }
 
    constexpr bool operator==(const Pin &rhs) const
    {
        return (rhs.port == port) && (rhs.pin == pin);
    }
 
    constexpr bool operator!=(const Pin &rhs) const { return !operator==(rhs); }
 
    constexpr operator dsy_gpio_pin() const
    {
        return dsy_gpio_pin{.port = static_cast<dsy_gpio_port>(port),
                            .pin  = pin};
    }
};
 
} // namespace daisy
 
#endif // __cplusplus
 
#endif