Utilities.h

Go to the documentation of this file.

#ifndef UTILITIES_H_
#define UTILITIES_H_

#include "Bela.h"

#ifndef INPUT
        #define INPUT 0x0
#endif /* INPUT */

#ifndef OUTPUT
        #define OUTPUT 0x1
#endif /* OUTPUT */

#define setBit(word,bit)                        ((word) | (1 << (bit)))

#define clearBit(word,bit)                      ((word) &~ (1 << (bit)))

#define getBit(word,bit)                        (((word) >> (bit)) & 1)

#define changeBit(word,bit,value)       ((clearBit((word),(bit))) | ((value) << (bit)))

// Note: pinMode(), analogWrite() and digitalWrite() should be able to be called from setup()
// Likewise, thread launch should be able to be called from setup()
// Also, make volume change functions callable from render() thread -- as an aux task?

static inline float audioRead(BelaContext *context, int frame, int channel);

static inline void audioWrite(BelaContext *context, int frame, int channel, float value);

static inline float analogRead(BelaContext *context, int frame, int channel);

static inline void analogWrite(BelaContext *context, int frame, int channel, float value);

static inline void analogWriteOnce(BelaContext *context, int frame, int channel, float value);

static inline int digitalRead(BelaContext *context, int frame, int channel);

static inline void digitalWrite(BelaContext *context, int frame, int channel, int value);

static inline void digitalWriteOnce(BelaContext *context, int frame, int channel, int value);

static inline void pinMode(BelaContext *context, int frame, int channel, int mode);

static inline void pinModeOnce(BelaContext *context, int frame, int channel, int mode);

static inline float map(float x, float in_min, float in_max, float out_min, float out_max);

static inline float constrain(float x, float min_val, float max_val);

static inline float min(float x, float y);

static inline float max(float x, float y);

// audioRead()
//
// Returns the value of the given audio input at the given frame number.
static inline float audioRead(BelaContext *context, int frame, int channel) {
        return context->audioIn[frame * context->audioInChannels + channel];
}

// audioWrite()
//
// Sets a given audio output channel to a value for the current frame
static inline void audioWrite(BelaContext *context, int frame, int channel, float value) {
        context->audioOut[frame * context->audioOutChannels + channel] = value;
}

// analogRead()
//
// Returns the value of the given analog input at the given frame number.
static inline float analogRead(BelaContext *context, int frame, int channel) {
        return context->analogIn[frame * context->analogInChannels + channel];
}

// analogWrite()
//
// Sets a given analog output channel to a value for the current frame and, if persistent outputs are
// enabled, for all subsequent frames
static inline void analogWrite(BelaContext *context, int frame, int channel, float value) {
        if(context->flags & BELA_FLAG_ANALOG_OUTPUTS_PERSIST) {
                for(unsigned int f = frame; f < context->analogFrames; f++)
                        context->analogOut[frame * context->analogOutChannels + channel] = value;
        }
        else
                context->analogOut[frame * context->analogOutChannels + channel] = value;
}

// analogWriteOnce()
//
// Sets a given channel to a value for only the current frame
static inline void analogWriteOnce(BelaContext *context, int frame, int channel, float value) {
        context->analogOut[frame * context->analogOutChannels + channel] = value;
}

// digitalRead()
//
// Returns the value of a given digital input at the given frame number
static inline int digitalRead(BelaContext *context, int frame, int channel) {
        return getBit(context->digital[frame], channel + 16);
}

// digitalWrite()
//
// Sets a given digital output channel to a value for the current frame and all subsequent frames
static inline void digitalWrite(BelaContext *context, int frame, int channel, int value) {
        for(unsigned int f = frame; f < context->digitalFrames; f++) {
                if(value)
                        context->digital[f] |= 1 << (channel + 16);
                else
                        context->digital[f] &= ~(1 << (channel + 16));
        }
}

// digitalWriteOnce()
//
// Sets a given digital output channel to a value for the current frame only
static inline void digitalWriteOnce(BelaContext *context, int frame, int channel, int value) {
        if(value)
                context->digital[frame] |= 1 << (channel + 16);
        else
                context->digital[frame] &= ~(1 << (channel + 16));
}

// pinMode()
//
// Sets the direction of a digital pin for the current frame and all subsequent frames
static inline void pinMode(BelaContext *context, int frame, int channel, int mode) {
        for(unsigned int f = frame; f < context->digitalFrames; f++) {
                if(mode == INPUT)
                        context->digital[f] |= (1 << channel);
                else
                        context->digital[f] &= ~(1 << channel);
        }
}

// pinModeOnce()
//
// Sets the direction of a digital pin for the current frame only
static inline void pinModeOnce(BelaContext *context, int frame, int channel, int mode) {
        if(mode == INPUT)
                context->digital[frame] |= (1 << channel);
        else
                context->digital[frame] &= ~(1 << channel);
}



// map()
//
// Scale an input value from one range to another. Works like its Wiring language equivalent.
// x is the value to scale; in_min and in_max are the input range; out_min and out_max
// are the output range.

static inline float map(float x, float in_min, float in_max, float out_min, float out_max)
{
        return (x - in_min) * (out_max - out_min) / (in_max - in_min) + out_min;
}

// constrain()
//
// Clips an input value to be between two end points
// x is the value to constrain; min_val and max_val are the range

static inline float constrain(float x, float min_val, float max_val)
{
        if(x < min_val) return min_val;
        if(x > max_val) return max_val;
        return x;
}

static inline float max(float x, float y){
        return x > y ? x : y;
}

static inline float min(float x, float y){
        return x < y ? x : y;
}

#endif /* UTILITIES_H_ */