Beispiel #1
0
        static IConnectableObservable<StrokeState> MakeStrokeStream(IConnection connection)
        {
            return Observable.Interval(TimeSpan.FromMilliseconds(10))
            .Select(_ =>
                {
                    var rspDataCount = m_RspReader.Capacity;

                    if (connection.SendCSAFECommand(m_100HzCommands.Buffer, m_100HzCommands.Size, m_RspReader.Buffer, ref rspDataCount))
                    {
                        // Reset the reader to the correct length
                        m_RspReader.Reset(rspDataCount);
                        m_100HzCommands.Read(m_RspReader);
                    }

                    return m_StrokeStateCommand.StrokeState;
                })
            //.Scan(Tuple.Create(StrokeState.Catch, StrokeState.Catch), (p, c) => Tuple.Create(p.Item2, c))
            //.Where(e => e.Item1 != e.Item2)
            //.Select(e => e.Item1)
            .Publish();
        }
Beispiel #2
0
        static IConnectableObservable<Tuple<uint, uint, uint, Time, uint, WorkoutState>> Make2HzStream(IConnection connection)
        {
            return Observable.Interval(TimeSpan.FromMilliseconds(10)).Select(_ =>
            {
                var rspDataCount = m_RspReader.Capacity;

                if (connection.SendCSAFECommand(m_2HzCommands.Buffer, m_2HzCommands.Size, m_RspReader.Buffer, ref rspDataCount))
                {
                    // Reset the reader to the correct length
                    m_RspReader.Reset(rspDataCount);
                    m_2HzCommands.Read(m_RspReader);
                }

                return Tuple.Create
                    (m_CadenceCommand.StrokeRate
                    , m_CaloriesCommand.Calories
                    , m_DragFactorCommand.DragFactor
                    , m_PaceCommand.Pace
                    , m_PowerCommand.Power
                    , m_WorkoutStateCommand.WorkoutState
                    );
            })
            .Publish();
        }
Beispiel #3
0
        static IConnectableObservable<Tuple<StrokeState, uint, Time, uint, uint, uint[]>> MakeEverythingStream(IConnection connection)
        {
            return Observable.Interval(TimeSpan.FromMilliseconds(10)).Select(_ =>
                {
                    var rspDataCount = m_RspReader.Capacity;

                    if (connection.SendCSAFECommand(everything.Buffer, everything.Size, m_RspReader.Buffer, ref rspDataCount))
                    {
                        // Reset the reader to the correct length
                        m_RspReader.Reset(rspDataCount);
                        everything.Read(m_RspReader);
                    }

                    return Tuple.Create
                        (m_StrokeStateCommand.StrokeState
                        , m_CaloriesCommand.Calories
                        , m_PaceCommand.Pace
                        , m_PowerCommand.Power
                        , m_CadenceCommand.StrokeRate
                        , m_ForcePlotDataCommand.Data
                        );
                })
                .Publish();
        }
Beispiel #4
0
        static IConnectableObservable<Tuple<Distance, Time, Distance, Time>> Make10HzStream(IConnection connection)
        {
            return Observable.Interval(TimeSpan.FromMilliseconds(10)).Select(_ =>
            {
                var rspDataCount = m_RspReader.Capacity;

                if (connection.SendCSAFECommand(m_10HzCommands.Buffer, m_10HzCommands.Size, m_RspReader.Buffer, ref rspDataCount))
                {
                    // Reset the reader to the correct length
                    m_RspReader.Reset(rspDataCount);
                    m_10HzCommands.Read(m_RspReader);
                }

                return Tuple.Create
                    ( m_DistanceCommand.Distance
                    , m_TimeCommand.Time
                    , m_WorkDistanceCommand.WorkDistance
                    , m_WorkTimeCommand.WorkTime
                    );
            })
            .Publish();
        }