source: orbit/iOS/Orbit/Orbit/SignalConverter.m

//
//  SignalConverter.m
//  orbit
//
//  Copyright (c) 2013 Puzzlebox Productions, LLC. All rights reserved.
//  Originally created by Jonathon Horsman.
//
//  This code is released under the GNU Public License (GPL) version 2
//  For more information please refer to http://www.gnu.org/copyleft/gpl.html
//

#import "SignalConverter.h"

#import "HistoryAppDataObject.h"
#import "AppDelegateProtocol.h"

#define AUDIO_FILE_NAME @"throttle_hover_ios.wav" // @"iOS_noflip.wav"
#define POOR_SIGNAL_KEY @"poorSignal"
#define ATTENTION_KEY @"eSenseAttention"
#define MEDITATION_KEY @"eSenseMeditation"

#define CHANNEL_A 1

// Converts signals received from the EEG headset to the audio played to fly the helicopter.
//
@implementation SignalConverter {
    // these 2 arrays hold the values of the thrust which should be applied to the helicopter
    // (by way of volume level through the headphones) at each level of attention and meditation.
    // this could be calculated on the fly, but because it happens ~20 times per second, the
    // better option is to store all the values in arrays, and recalculate when the sliders are changed.
    float attentionPower[101];
    float meditationPower[101];
    
    int signalStrength, attentionLevel, meditationLevel; // the latest readings from the headset
    int yaw, throttle, pitch;
    
    int historyAttention[30];
    int historyMeditation[30];
    int historyIndex;
    
}

@synthesize attentionThreshold, meditationThreshold, running, testing;


- (id) init
{
    self = [super init];
    if (self)
    {
        [[TGAccessoryManager sharedTGAccessoryManager] setupManagerWithInterval:0.05];
        [[TGAccessoryManager sharedTGAccessoryManager] setDelegate:self];
        // Generate Signal
        //        audioPlayer = [[AudioGenerator alloc] init];
        
        // defaults
        throttle = 80;
        yaw = 78;
        pitch = 31;
        
        historyIndex = 0;
        
        // initialise the audio session - this should only be done once
        AudioSessionInitialize(NULL, NULL, NULL, NULL);
        AudioSessionSetActive(YES);
        
#if USE_AUDIO_GENERATOR
        audioPlayer = [[AudioGenerator alloc] init];
#endif
    }
    return self;
}

#pragma mark -
#pragma mark instance methods

- (HistoryAppDataObject*) theAppDataObject;
{
    id<AppDelegateProtocol> theDelegate = (id<AppDelegateProtocol>) [UIApplication sharedApplication].delegate;
    HistoryAppDataObject* theDataObject;
    theDataObject = (HistoryAppDataObject*) theDelegate.theAppDataObject;
    return theDataObject;
}

- (void) setValuesForAttention:(float) attention meditation:(float) meditation
{
    attentionThreshold = attention;
    meditationThreshold = meditation;
    [self calculatePowerValues];
}

- (void) appStopped
{
    running = NO;
    if ([TGAccessoryManager sharedTGAccessoryManager].accessory != nil) {
        [[TGAccessoryManager sharedTGAccessoryManager] stopStream];
    }
    [audioPlayer stop];
    if (_delegate != nil) {
        [_delegate appStopped];
    }
    AudioSessionSetActive(NO);
}

#pragma mark - TGAccessoryDelegate methods

- (void)dataReceived:(NSDictionary *)data {
    [self performSelectorOnMainThread:@selector(updatedSignalReceived:)
                           withObject:data
                        waitUntilDone:NO];
}

// Updated signal received from the EEG headset.
- (void) updatedSignalReceived:(id) data
{
    [self setValuesFromData:data];
    // notify listening delegates of updated values so the UI can be updated
    if (_delegate != nil)
    {
        [_delegate updatedValuesForSignal: signalStrength
                                attention: (float)attentionLevel / 100
                               meditation: (float)meditationLevel / 100
                                    power: [self currentPowerLevel]];
    }
    [self playAudio];
}

- (void) setValuesFromData:(id) data
{
    [self setSignalStrength:(NSNumber *)[data valueForKey:POOR_SIGNAL_KEY]];
    [self setAttentionLevel:(NSNumber *)[data valueForKey:ATTENTION_KEY]];
    [self setMeditationLevel:(NSNumber *)[data valueForKey:MEDITATION_KEY]];
    
    historyAttention[historyIndex] = attentionLevel;
    historyMeditation[historyIndex] = meditationLevel;
    
    historyIndex = historyIndex + 1;
    
    HistoryAppDataObject* theDataObject = [self theAppDataObject];
    theDataObject.lastAttention = attentionLevel;
    theDataObject.lastMeditation = meditationLevel;

    
    if (historyIndex == 30) {
        NSLog(@"History Arrays Full");
        historyIndex = 0;
        
        for (int i=0; i<30; i++){
            NSLog(@"%d: %d", i, historyMeditation[i]);
        }
        
    }
    
}

- (void) setSignalStrength:(NSNumber *) value
{
    if (value != nil) {
        
        //        NSLog(@"value: %i", [value intValue]);
        
        if ([value intValue] == 0) {
            signalStrength = 100;
        }
        
        else if ([value intValue] == 200) {
            signalStrength = 0;
        }
        
        else {
            signalStrength = [value intValue];
        }
        
        //        NSLog(@"signalStrength: %i", signalStrength);
        
    }
}

- (void) setAttentionLevel:(NSNumber *) value
{
    if (value != nil) {
        attentionLevel = [value intValue];
    }
}

- (void) setMeditationLevel:(NSNumber *) value
{
    if (value != nil) {
        meditationLevel = [value intValue];
    }
}

// The headset was switched on, start the data stream
- (void)accessoryDidConnect:(EAAccessory *)accessory {
}

// The headset was switched off (or the Bluetooth signal was dropped).
- (void)accessoryDidDisconnect {
    if (_delegate != nil)
    {
        [_delegate notifyHeadsetDisconnect];
    }
}

- (BOOL) isBluetoothReady
{
    return [[TGAccessoryManager sharedTGAccessoryManager] accessory] != NULL;
}

- (BOOL) isVolumeMax
{
    Float32 volume;
    UInt32 dataSize;
    AudioSessionGetPropertySize(kAudioSessionProperty_CurrentHardwareOutputVolume, &dataSize);
    AudioSessionGetProperty(kAudioSessionProperty_CurrentHardwareOutputVolume, &dataSize, &volume);
    //    NSLog(@"Volume is %f", volume);
    return 1.0 == volume;
}

- (BOOL) isAudioJackPlugged
{
    UInt32 routeSize;
    
    // oddly, without calling this method caused an error.
    AudioSessionGetPropertySize(kAudioSessionProperty_AudioRouteDescription, &routeSize);
    CFDictionaryRef desc; // this is the dictionary to contain descriptions
    
    // make the call to get the audio description and populate the desc dictionary
    AudioSessionGetProperty(kAudioSessionProperty_AudioRouteDescription, &routeSize, &desc);
    
    // the dictionary contains 2 keys, for input and output. Get output array
    CFArrayRef outputs = CFDictionaryGetValue(desc, kAudioSession_AudioRouteKey_Outputs);
    
    // the output array contains 1 element - a dictionary
    CFDictionaryRef dict = CFArrayGetValueAtIndex(outputs, 0);
    
    // get the output description from the dictionary
    CFStringRef output = CFDictionaryGetValue(dict, kAudioSession_AudioRouteKey_Type);
    
    /**
     These are the possible output types:
     kAudioSessionOutputRoute_LineOut
     kAudioSessionOutputRoute_Headphones
     kAudioSessionOutputRoute_BluetoothHFP
     kAudioSessionOutputRoute_BluetoothA2DP
     kAudioSessionOutputRoute_BuiltInReceiver
     kAudioSessionOutputRoute_BuiltInSpeaker
     kAudioSessionOutputRoute_USBAudio
     kAudioSessionOutputRoute_HDMI
     kAudioSessionOutputRoute_AirPlay
     */
    
    return CFStringCompare(output, kAudioSessionOutputRoute_Headphones, 0) == kCFCompareEqualTo;
}

#pragma mark start / stop methods

- (BOOL) startProcessing
{
    if (testing) return NO;
    EAAccessory *accessory = [[TGAccessoryManager sharedTGAccessoryManager] accessory];
    if (accessory != nil) {
        running = YES;
        if (_delegate != nil) {
            [_delegate notifyDeviceConnected: accessory.name];
        }
        [[TGAccessoryManager sharedTGAccessoryManager] startStream];
    }
    return running;
}

- (void) stopProcessing
{
    if (running) [self appStopped];
}

- (void) playTestSound
{
    if (!running && !testing) {
        testing = YES;
#if USE_AUDIO_GENERATOR
        // Generate Sound
        [audioPlayer playWithThrottle:throttle yaw:yaw pitch:pitch];
#else
        // Play WAV
        [self prepareAudio];
        [audioPlayer play];
#endif
    }
}

- (void) stopTestSound
{
    if (testing) {
        testing = NO;
        [audioPlayer stop];
    }
}

#pragma mark internal processing methods

// Calculate power for throttle. In theory this can be tied to the amount of throttle
// to set based on how far based the trigger thresholds attention and meditation are
// currently measured
- (float) currentPowerLevel
{
    
    float attentionScore = attentionPower[attentionLevel];
    float meditationScore = meditationPower[meditationLevel];
    
    if (attentionThreshold == 0.0) {
        attentionScore = 0;
    }
    
    if (meditationThreshold == 0.0) {
        meditationScore = 0;
    }
    
    float powerLevel = attentionScore + meditationScore;
    
    // For now just set Power to 100% if helicopter should be flying
    //    if (powerLevel > 1) {
    if (powerLevel > 0) {
        return 1.0;
    }
    return powerLevel;
}

- (void) setControlSettings:(int)y throttle:(int)t pitch:(int)p
{
    
    //    NSLog(@"DEBUG: Signal Converter: throttle:%d yaw:%d pitch:%d", t, y, p);
    
    throttle = t;
    yaw = y;
    pitch = p;
    
    if (testing) {
        [audioPlayer playWithThrottle:throttle yaw:yaw pitch:pitch];
    }
    
}


- (void) playAudio
{
    
    //   audioPlayer.volume = [self currentPowerLevel];
    if ([self currentPowerLevel] > 0) {
        
#if USE_AUDIO_GENERATOR
        // Generate Signal
        [audioPlayer playWithThrottle:throttle yaw:yaw pitch:pitch];
#else
        audioPlayer.volume = 1.0;
        
        // Play WAV
        [self prepareAudio];
        [audioPlayer play];
#endif
        
    } else {
        [audioPlayer stop];
        [self prepareAudio];
        
    }
}

#pragma mark - display calculation and update methods

// when the user adjusts one of the 2 threshold sliders we recalculate the power values at each of the 101 possible levels
- (void) calculatePowerValues
{
    for (int i = 0; i < 101; i++) {
        attentionPower[i] = [self calculatePowerAt:(float)i/100 withThreshold:attentionThreshold];
    }
    for (int i = 0; i < 101; i++) {
        meditationPower[i] = [self calculatePowerAt:(float)i/100 withThreshold:meditationThreshold];
    }
}

// Convert a value (attention or meditation) into the corresponding power output (which is the volume level)
// given the threshold is set at specified value.
// The threshold is the value set by the user as the minimum value (attention or meditation) to be reached
// before the helicopter is given the signal to fly.
// If the value if below the threshold, the value will be zero (threshold not yet met).
// Otherwise the returned power value will be between 0 and 1.
- (float) calculatePowerAt:(float)value withThreshold:(float)threshold
{
    if (value < threshold) { // threshold not met
        return 0;
    }
    // e.g. if the threshold is 0.55 and the current value is 0.7:
    // there is 0.45 remaining of the threshold slider, and the value is 0.15 past the threshold (0.7 - 0.55), which is 0.33 (0.15 / 0.45)
    return (value - threshold) / (1 - threshold);
}

- (void) prepareAudio
{
#if USE_AUDIO_GENERATOR
#else
    NSURL *audioFilePath = [[NSBundle mainBundle] URLForResource:AUDIO_FILE_NAME withExtension:nil];
    
    NSError *error;
    audioPlayer = [[AVAudioPlayer alloc] initWithContentsOfURL:audioFilePath error:&error];
    if (!audioPlayer) {
        //        [self logMessage:[NSString stringWithFormat:@"Failed to initialize audio player: %@", [error debugDescription]]];
        NSLog(@"Failed to initialize audio player: %@", [error debugDescription]);
    } else {
        [audioPlayer prepareToPlay];
    }
#endif
}

- (int) getAttentionHistory:(int) index
{
    return historyAttention[index];
}

@end