DigitalChannelManager.h

/*
 * DigitalStream.h
 *
 *  Created on: 7 Jun 2016
 *      Author: giulio
 */
 
#ifndef DIGITALCHANNELMANAGER_H_
#define DIGITALCHANNELMANAGER_H_
#include <Bela.h>

 
class DigitalChannelManager {
public:
        DigitalChannelManager();

 
        void setCallback(void (*newCallback)(bool, unsigned int, void*)){
                stateChangedCallback = newCallback;
                if(newCallback != NULL){
                        callbackEnabled = true;
                } else {
                        callbackEnabled = false;
                }
        };

        void setCallbackArgument(unsigned int channel, void* arg){
                callbackArguments[channel] = arg;
        }

        void processInput(uint32_t* array, unsigned int length){
                if(callbackEnabled == false){
                        return;
                }
                // DIGITAL_FORMAT_ASSUMPTION
                static uint16_t lastDigitalInputValues = 0;
                for (unsigned int frame = 0; frame < length; ++frame) {
                        uint32_t inWord = array[frame];
                        uint16_t direction = inWord & 0Xffff;
                        uint16_t inputValues = (inWord >> 16);
                        // note: even though INPUT == 0 and OUTPUT == 0, this is actually reversed in the binary word,
                        // so it actually is 1 for input and 0 for output
 
                        // mask out outputValues from the half-word by setting them to zero
                        // if a bit of direction is 1, then it is an input.
                        // ANDing this with the inputValues gets rid of the output values
                        inputValues &= direction;
                        uint16_t changed = inputValues ^ lastDigitalInputValues;
                        //mask out channels that are not set at message rate
                        changed &= messageRate;
                        if(changed){
//                              rt_printf("changed: 0x%x, messageRate: 0x%x, ANDed: 0x%x\n", changed, messageRate, changed&messageRate);
                                for(int n = 0; n < 16; ++n){
                                        if(changed & (1 << n)){ //if state for this channel has changed, invoke the callback
                                                stateChangedCallback(inputValues & (1 << n), frame, callbackArguments[n]);
                                        }
                                }
                        }
                        lastDigitalInputValues = inputValues;
                }
        }

        void processOutput(uint32_t* array, unsigned int length){
                uint32_t orWord = ((setDataOut << 16) | modeInput);
                uint32_t andWord = ~((clearDataOut << 16) | modeOutput);
                uint32_t outWord;
                for (unsigned int frame = 0; frame < length; ++frame) {
                        outWord = array[frame];
                        outWord = outWord | orWord;
                        outWord = outWord & andWord;
                        array[frame] = outWord;
                }
        }

        bool isSignalRate(unsigned int channel){
                return (bool)((1 << channel) & signalRate);
        }

        bool isMessageRate(unsigned int channel){
                return (bool)((1 << channel) & messageRate);
        }

        bool isInput(unsigned int channel){
                return (bool)((1 << channel) & modeInput);
        }

        bool isOutput(unsigned int channel){
                return (bool)((1 << channel) & modeOutput);
        }

        void setValue(unsigned int channel, bool value){
                if(value == 0){
                        clearDataOut = Bela_setBit(clearDataOut, channel);
                        setDataOut = Bela_clearBit(setDataOut, channel);
                } else {
                        setDataOut = Bela_setBit(setDataOut, channel);
                        clearDataOut = Bela_clearBit(clearDataOut, channel);
                }
        }

        void unmanage(unsigned int channel){
                messageRate = Bela_clearBit(messageRate, channel);
                signalRate = Bela_clearBit(signalRate, channel);
                modeInput = Bela_clearBit(modeInput, channel);
                modeOutput = Bela_clearBit(modeOutput, channel);
                clearDataOut = Bela_clearBit(clearDataOut, channel);
                setDataOut = Bela_clearBit(setDataOut, channel);
        }

        void manage(unsigned int channel, bool direction, bool isMessageRate){
                // direction is expected to be one of INPUT or OUTPUT
                messageRate = Bela_changeBit(messageRate, channel, isMessageRate);
                signalRate = Bela_changeBit(signalRate, channel, !isMessageRate);
                if(direction == OUTPUT){
                        modeOutput = Bela_setBit(modeOutput, channel);
                        modeInput = Bela_clearBit(modeInput, channel);
                } else { // direction == INPUT
                        modeInput = Bela_setBit(modeInput, channel);
                        modeOutput = Bela_clearBit(modeOutput, channel);
                }
                if(verbose)
                        rt_printf("Bela digital: channel %d is set as %s at %s rate\n", channel,
                                isInput(channel) ? "input" : "output", isSignalRate(channel) ? "signal" : "message");
        }
 
        void setVerbose(bool isVerbose);
        virtual ~DigitalChannelManager();
private:
        bool callbackEnabled;
        void* callbackArguments[16];
        void (*stateChangedCallback)(bool value, unsigned int delay, void* arg);
        uint32_t clearDataOut;
        uint32_t setDataOut;
        uint16_t modeOutput;
        uint16_t modeInput;
        uint16_t messageRate;
        uint16_t signalRate;
        bool verbose;
};
 
#endif /* DIGITALCHANNELMANAGER_H_ */