Software_2017/src/main/java/com/easternedgerobotics/rov/io/panel/SliderController.java at b57d88b860f87d2bd195ab968cdfd558201d756d · EasternEdgeRobotics/Software_2017 · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
package com.easternedgerobotics.rov.io.panel;

import com.easternedgerobotics.rov.config.SliderConfig;
import com.easternedgerobotics.rov.control.AnalogToPowerLevel;
import com.easternedgerobotics.rov.control.SourceController;
import com.easternedgerobotics.rov.event.EventPublisher;
import com.easternedgerobotics.rov.io.devices.IOBoard;
import com.easternedgerobotics.rov.value.AftPowerValue;
import com.easternedgerobotics.rov.value.AnalogPinValue;
import com.easternedgerobotics.rov.value.ForePowerValue;
import com.easternedgerobotics.rov.value.GlobalPowerValue;
import com.easternedgerobotics.rov.value.HeavePowerValue;
import com.easternedgerobotics.rov.value.LightAValue;
import com.easternedgerobotics.rov.value.LightBValue;
import com.easternedgerobotics.rov.value.PitchPowerValue;
import com.easternedgerobotics.rov.value.SurgePowerValue;
import com.easternedgerobotics.rov.value.SwayPowerValue;
import com.easternedgerobotics.rov.value.YawPowerValue;

import rx.Observable;
import rx.Scheduler;
import rx.schedulers.Schedulers;
import rx.subscriptions.CompositeSubscription;

public final class SliderController {
    private final CompositeSubscription subscription = new CompositeSubscription();

    public SliderController(
        final IOBoard io,
        final Scheduler scheduler,
        final EventPublisher eventPublisher,
        final SliderConfig config
    ) {
        final Observable<GlobalPowerValue> global = io.analogPin(config.globalPowerSliderAddress())
            .map(AnalogPinValue::getValue).map(AnalogToPowerLevel::convertNeg).map(GlobalPowerValue::new);

        final Observable<HeavePowerValue> heave = io.analogPin(config.heavePowerSliderAddress())
            .map(AnalogPinValue::getValue).map(AnalogToPowerLevel::convertNeg).map(HeavePowerValue::new);

        final Observable<SwayPowerValue> sway = io.analogPin(config.swayPowerSliderAddress())
            .map(AnalogPinValue::getValue).map(AnalogToPowerLevel::convertNeg).map(SwayPowerValue::new);

        final Observable<SurgePowerValue> surge = io.analogPin(config.surgePowerSliderAddress())
            .map(AnalogPinValue::getValue).map(AnalogToPowerLevel::convertNeg).map(SurgePowerValue::new);

        final Observable<PitchPowerValue> pitch = io.analogPin(config.pitchPowerSliderAddress())
            .map(AnalogPinValue::getValue).map(AnalogToPowerLevel::convertNeg).map(PitchPowerValue::new);

        final Observable<YawPowerValue> yaw = io.analogPin(config.yawPowerSliderAddress())
            .map(AnalogPinValue::getValue).map(AnalogToPowerLevel::convertNeg).map(YawPowerValue::new);

        final Observable<AftPowerValue> aft = io.analogPin(config.aftPowerSliderAddress())
            .map(AnalogPinValue::getValue).map(AnalogToPowerLevel::convertNeg).map(AftPowerValue::new);

        final Observable<ForePowerValue> fore = io.analogPin(config.forePowerSliderAddress())
            .map(AnalogPinValue::getValue).map(AnalogToPowerLevel::convertNeg).map(ForePowerValue::new);

        final Observable<LightAValue> lightA = io.analogPin(config.lightAPowerSliderAddress())
            .map(AnalogPinValue::getValue).map(AnalogToPowerLevel::convertBool).map(LightAValue::new);

        final Observable<LightBValue> lightB = io.analogPin(config.lightBPowerSliderAddress())
            .map(AnalogPinValue::getValue).map(AnalogToPowerLevel::convertBool).map(LightBValue::new);

        subscription.addAll(
            SourceController.manageMultiViewModel(
                eventPublisher.valuesOfType(GlobalPowerValue.class), v -> { }, scheduler,
                global, eventPublisher::emit, Schedulers.io()),
            SourceController.manageMultiViewModel(
                eventPublisher.valuesOfType(HeavePowerValue.class), v -> { }, scheduler,
                heave, eventPublisher::emit, Schedulers.io()),
            SourceController.manageMultiViewModel(
                eventPublisher.valuesOfType(SwayPowerValue.class), v -> { }, scheduler,
                sway, eventPublisher::emit, Schedulers.io()),
            SourceController.manageMultiViewModel(
                eventPublisher.valuesOfType(SurgePowerValue.class), v -> { }, scheduler,
                surge, eventPublisher::emit, Schedulers.io()),
            SourceController.manageMultiViewModel(
                eventPublisher.valuesOfType(PitchPowerValue.class), v -> { }, scheduler,
                pitch, eventPublisher::emit, Schedulers.io()),
            SourceController.manageMultiViewModel(
                eventPublisher.valuesOfType(YawPowerValue.class), v -> { }, scheduler,
                yaw, eventPublisher::emit, Schedulers.io()),
            SourceController.manageMultiViewModel(
                eventPublisher.valuesOfType(AftPowerValue.class), v -> { }, scheduler,
                aft, eventPublisher::emit, Schedulers.io()),
            SourceController.manageMultiViewModel(
                eventPublisher.valuesOfType(ForePowerValue.class), v -> { }, scheduler,
                fore, eventPublisher::emit, Schedulers.io()),
            SourceController.manageMultiViewModel(
                eventPublisher.valuesOfType(LightAValue.class), v -> { }, scheduler,
                lightA, eventPublisher::emit, Schedulers.io()),
            SourceController.manageMultiViewModel(
                eventPublisher.valuesOfType(LightBValue.class), v -> { }, scheduler,
                lightB, eventPublisher::emit, Schedulers.io()));
    }

    public void stop() {
        subscription.clear();
    }
}