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

//
//  SignalConverter.m
//  orbit
//
//  Created by Jonathon Horsman on 11/07/2013.
//  Copyright (c) 2013 Puzzlebox Productions, LLC. All rights reserved.
//

#import "SignalConverter.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;
}

@synthesize attentionThreshold, meditationThreshold, running, testing;


- (id) init
{
    self = [super init];
    if (self)
    {
        [[TGAccessoryManager sharedTGAccessoryManager] setupManagerWithInterval:0.05];
        [[TGAccessoryManager sharedTGAccessoryManager] setDelegate:self];
        audioPlayer = [[AudioGenerator alloc] init];
        
        // defaults
        throttle = 80;
        yaw = 78;
        pitch = 31;
    }
    return self;
}

- (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];
    }
}

#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]];    
}

- (void) setSignalStrength:(NSNumber *) value
{
    if (value != nil) {
        signalStrength = (200.0 - [value intValue]) / 200.0;
    }
}

- (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
{
    AudioSessionSetActive(YES);
    return 1.0 == [[AVAudioSession sharedInstance] outputVolume];
}

#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;
        [audioPlayer playWithThrottle:throttle yaw:yaw pitch:pitch];
    }
}

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

#pragma mark internal processing methods

// calculate the total power level to output through the headphones, a value between zero and 1.
// this is the attention signal level and meditation signal level added together
- (float) currentPowerLevel
{
    float powerLevel = attentionPower[attentionLevel] + meditationPower[meditationLevel];
    if (powerLevel > 1) {
        return 1.0;
    }
    return powerLevel;
}

- (void) setYaw:(int)y throttle:(int)t pitch:(int)p
{
    yaw = y;
    throttle = t;
    pitch = p;
}

- (void) playAudio
{
    if ([self currentPowerLevel] > 0) {
        [audioPlayer playWithThrottle:throttle yaw:yaw pitch:pitch];
    } else {
        [audioPlayer stop];
        
    }
}

#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);
}

@end