/// <summary> /// Creates an instacne of a counter from a <see cref="DigitalSource"/>. /// </summary> /// <remarks> /// This constructor should be used if an existing <see cref="DigitalSource"/> is to /// be shared by multiple other objects such as <see cref="Encoder">Encoders</see> or if /// the <see cref="DigitalSource"/> is not a DIO Channel (for instance a <see cref="AnalogTrigger"/>. /// <para>The counter will start couting immediately.</para> /// </remarks> /// <param name="source">The <see cref="DigitalSource"/> to count.</param> public Counter(DigitalSource source) { if (source == null) throw new ArgumentNullException(nameof(source), "Digital Source given was null"); InitCounter(Mode.TwoPulse); SetUpSource(source); }
public Counter(DigitalSource source) { if (source == null) throw new NullReferenceException("Digital Source given was null"); InitCounter(Mode.TwoPulse); SetUpSource(source); }
/// <inheritdoc/> public override void Dispose() { if (ASource != null && m_allocatedA) { ASource.Dispose(); m_allocatedA = false; } if (BSource != null && m_allocatedB) { BSource.Dispose(); m_allocatedB = false; } if (IndexSource != null && m_allocatedI) { IndexSource.Dispose(); m_allocatedI = false; } ASource = null; BSource = null; IndexSource = null; int status = 0; HAL_FreeEncoder(m_encoder, ref status); CheckStatus(status); }
/// <summary> /// Creates an instance of a Counter object from specified <see cref="DigitalSource"> /// Digital Sources</see> for up and down counts. /// </summary> /// <remarks> /// The counter will start counting immediately. /// </remarks> /// <param name="encodingType">The EncodingType for the counter. <see cref="EncodingType.K4X"/> is not supported.</param> /// <param name="upSource">The <see cref="DigitalSource"/> to use for up counting.</param> /// <param name="downSource">The <see cref="DigitalSource"/> to use for down counting.</param> /// <param name="inverted">True to invert the direction of counting.</param> public Counter(EncodingType encodingType, DigitalSource upSource, DigitalSource downSource, bool inverted) { if (encodingType != EncodingType.K2X && encodingType != EncodingType.K1X) { throw new ArgumentOutOfRangeException(nameof(encodingType), "Counters only support 1X and 2X decoding!"); } if (upSource == null) { throw new ArgumentNullException(nameof(upSource), "Up Source given was null"); } if (downSource == null) { throw new ArgumentNullException(nameof(downSource), "Down Source given was null"); } InitCounter(Mode.ExternalDirection); SetUpSource(upSource); SetDownSource(downSource); int status = 0; if (encodingType == EncodingType.K1X) { SetUpSourceEdge(true, false); HAL_SetCounterAverageSize(m_counter, 1, ref status); } else { SetUpSourceEdge(true, true); HAL_SetCounterAverageSize(m_counter, 2, ref status); } CheckStatus(status); SetDownSourceEdge(inverted, true); }
//External direction is encoder style. public Counter(EncodingType encodingType, DigitalSource upSource, DigitalSource downSource, bool inverted) { InitCounter(Mode.ExternalDirection); if (encodingType != EncodingType.K2X && encodingType != EncodingType.K1X) { throw new ArgumentOutOfRangeException(nameof(encodingType), "Counters only support 1X and 2X decoding!"); } if (upSource == null) throw new ArgumentNullException(nameof(upSource), "Up Source given was null"); if (downSource == null) throw new ArgumentNullException(nameof(downSource), "Down Source given was null"); SetUpSource(upSource); SetDownSource(downSource); int status = 0; if (encodingType == EncodingType.K1X) { SetUpSourceEdge(true, false); SetCounterAverageSize(m_counter, 1, ref status); } else { SetUpSourceEdge(true, true); SetCounterAverageSize(m_counter, 2, ref status); } CheckStatus(status); SetDownSourceEdge(inverted, true); }
/// <summary> /// Sets the index source for the encoder. Resets based on the <see cref="IndexingType"/> passed. /// </summary> /// <param name="source">The <see cref="DigitalSource"/> to set as the encoder index.</param> /// <param name="type">The state that will cause the encoder to reset.</param> public void SetIndexSource(DigitalSource source, IndexingType type = IndexingType.ResetOnRisingEdge) { int status = 0; HAL_SetEncoderIndexSource(m_encoder, source.PortHandleForRouting, (HALAnalogTriggerType)source.AnalogTriggerTypeForRouting, (HALEncoderIndexingType)type, ref status); CheckStatus(status); }
/// <summary> /// Construct an Encoder given A and B Channels. /// </summary> /// <remarks>The encoder will start counting immediately.</remarks> /// <param name="aChannel">The A channel DIO channel. 0-9 are on-board, 10-25 are on the MXP port.</param> /// <param name="bChannel">The B channel DIO channel. 0-9 are on-board, 10-25 are on the MXP port.</param> /// <param name="reverseDirection">True if to reverse the output, otherwise false</param> public Encoder(int aChannel, int bChannel, bool reverseDirection = false) { m_allocatedA = true; m_allocatedB = true; m_allocatedI = false; ASource = new DigitalInput(aChannel); BSource = new DigitalInput(bChannel); InitEncoder(reverseDirection, EncodingType.K4X); }
/// <summary> /// Creates an instacne of a counter from a <see cref="DigitalSource"/>. /// </summary> /// <remarks> /// This constructor should be used if an existing <see cref="DigitalSource"/> is to /// be shared by multiple other objects such as <see cref="Encoder">Encoders</see> or if /// the <see cref="DigitalSource"/> is not a DIO Channel (for instance a <see cref="AnalogTrigger"/>. /// <para>The counter will start couting immediately.</para> /// </remarks> /// <param name="source">The <see cref="DigitalSource"/> to count.</param> public Counter(DigitalSource source) { if (source == null) { throw new ArgumentNullException(nameof(source), "Digital Source given was null"); } InitCounter(Mode.TwoPulse); SetUpSource(source); }
public Encoder(int aChannel, int bChannel, bool reverseDirection) { m_allocatedA = true; m_allocatedB = true; m_allocatedI = false; m_aSource = new DigitalInput(aChannel); m_bSource = new DigitalInput(bChannel); InitEncoder(reverseDirection); }
/// <summary> /// Sets the index source for the encoder. Resets based on the <see cref="IndexingType"/> passed. /// </summary> /// <param name="channel">The DIO channel to set as the encoder index.</param> /// <param name="type">The state that will cause the encoder to reset.</param> public void SetIndexSource(int channel, IndexingType type = IndexingType.ResetOnRisingEdge) { if (m_allocatedI) { throw new AllocationException("Digital Input for Indexing already allocated"); } IndexSource = new DigitalInput(channel); m_allocatedI = true; SetIndexSource(IndexSource, type); }
private static void SetFilter(DigitalSource input, int channelIndex) { if (input != null) { int status = 0; SetFilterSelect(input.Port, channelIndex, ref status); CheckStatus(status); int selected = GetFilterSelect(input.Port, ref status); CheckStatus(status); if (selected != channelIndex) throw new InvalidOperationException($"SetFilterSelect for {channelIndex} failed -> {selected}"); } }
/// <summary> /// Sets the down source object for the counter. /// </summary> /// <param name="source">The DigitalSource to use for counting down.</param> public void SetDownSource(DigitalSource source) { if (m_downSource != null && m_allocatedDownSource) { m_downSource.Dispose(); m_allocatedDownSource = false; } m_downSource = source; int status = 0; HAL_SetCounterDownSource(m_counter, source.PortHandleForRouting, (HALAnalogTriggerType)source.AnalogTriggerTypeForRouting, ref status); CheckStatus(status); }
/// <summary> /// Disable the down counting source of the counter. /// </summary> public void ClearDownSource() { if (m_downSource != null && m_allocatedDownSource) { m_downSource.Dispose(); m_allocatedDownSource = false; } m_downSource = null; int status = 0; HAL_ClearCounterDownSource(m_counter, ref status); CheckStatus(status); }
private static void SetFilter(DigitalSource input, int channelIndex) { if (input != null) { int status = 0; HAL_SetFilterSelect(input.PortHandleForRouting, channelIndex, ref status); CheckStatus(status); int selected = HAL_GetFilterSelect(input.PortHandleForRouting, ref status); CheckStatus(status); if (selected != channelIndex) { throw new InvalidOperationException($"SetFilterSelect for {channelIndex} failed -> {selected}"); } } }
/// <inheritdoc/> public override void Dispose() { UpdateWhenEmpty = true; ClearUpSource(); ClearDownSource(); int status = 0; HAL_FreeCounter(m_counter, ref status); CheckStatus(status); m_upSource = null; m_downSource = null; m_counter = 0; }
private void InitCounter(Mode mode) { int status = 0; m_counter = InitializeCounter(mode, ref m_index, ref status); CheckStatus(status); m_allocatedUpSource = false; m_allocatedDownSource = false; m_upSource = null; m_downSource = null; MaxPeriod = 0.5; m_distancePerPulse = 1; Report(ResourceType.kResourceType_Counter, (byte)m_index, (byte)mode); }
private void InitCounter(Mode mode) { int status = 0; m_counter = HAL_InitializeCounter((HALCounterMode)mode, ref m_index, ref status); CheckStatusForceThrow(status); m_allocatedUpSource = false; m_allocatedDownSource = false; m_upSource = null; m_downSource = null; MaxPeriod = 0.5; DistancePerPulse = 1; Report(ResourceType.kResourceType_Counter, (byte)m_index, (byte)mode); }
/// <summary> /// Construct an Encoder given precreated A and B Channels as <see cref="DigitalSource">DigitalSources</see>. /// </summary> /// <remarks>The encoder will start counting immediately.</remarks> /// <param name="aSource">The A channel <see cref="DigitalSource"/></param> /// <param name="bSource">The B channel <see cref="DigitalSource"/></param> /// <param name="reverseDirection">True if to reverse the output, otherwise false</param> public Encoder(DigitalSource aSource, DigitalSource bSource, bool reverseDirection = false) { m_allocatedA = false; m_allocatedB = false; m_allocatedI = false; if (aSource == null) { throw new ArgumentNullException(nameof(aSource), "Digital Source A was null"); } ASource = aSource; if (bSource == null) { throw new ArgumentNullException(nameof(bSource), "Digital Source B was null"); } BSource = bSource; InitEncoder(reverseDirection, EncodingType.K4X); }
public void SetIndexSource(DigitalSource source) { SetIndexSource(source, IndexingType.ResetOnRisingEdge); }
public void SetIndexSource(DigitalSource source, IndexingType type) { int status = 0; bool activeHigh = (type == IndexingType.ResetWhileHigh) || (type == IndexingType.ResetOnRisingEdge); bool edgeSensitive = (type == IndexingType.ResetOnFallingEdge) || (type == IndexingType.ResetOnRisingEdge); SetEncoderIndexSource(m_encoder, (uint)source.ChannelForRouting, source.AnalogTriggerForRouting, activeHigh, edgeSensitive, ref status); CheckStatus(status); }
public override void Dispose() { if (m_aSource != null && m_allocatedA) { m_aSource.Dispose(); m_allocatedA = false; } if (m_bSource != null && m_allocatedB) { m_bSource.Dispose(); m_allocatedB = false; } if (m_indexSource != null && m_allocatedI) { m_indexSource.Dispose(); m_allocatedI = false; } m_aSource = null; m_bSource = null; m_indexSource = null; if (m_counter != null) { m_counter.Dispose(); m_counter = null; } else { int status = 0; FreeEncoder(m_encoder, ref status); CheckStatus(status); } }
public Encoder(DigitalSource aSource, DigitalSource bSource, DigitalSource indexSource) : this(aSource, bSource, indexSource, false) { }
/// <summary> /// Removes this filter from the given digital input. /// </summary> /// <param name="input">The <see cref="DigitalSource"/> to stop filtering.</param> public void Remove(DigitalSource input) { SetFilter(input, 0); }
public void ClearDownSource() { if (m_downSource != null && m_allocatedDownSource) { m_downSource.Dispose(); m_allocatedDownSource = false; } m_downSource = null; int status = 0; ClearCounterDownSource(m_counter, ref status); CheckStatus(status); }
/// <summary> /// Construct a <see cref="GearTooth"/> sensor given a <see cref="DigitalSource"/>. /// </summary> /// <remarks>No direction sensing is assumed.</remarks> /// <param name="source">An existing <see cref="DigitalSource"/> object /// (such as a <see cref="DigitalInput"/></param> public GearTooth(DigitalSource source) : this(source, false) { }
/// <summary> /// Construct a <see cref="GearTooth"/> sensor given a <see cref="DigitalSource"/>. /// </summary> /// <remarks>This should be used when sharing digital inputs</remarks> /// <param name="source">An existing <see cref="DigitalSource"/> object /// (such as a <see cref="DigitalInput"/></param> /// <param name="directionSensitive">True to enable direction sensing.</param> public GearTooth(DigitalSource source, bool directionSensitive) : base(source) { DirectionSensing = directionSensitive; }
/// <summary> /// Removes this filter from the given digital input. /// </summary> /// <param name="input">The <see cref="DigitalSource"/> to stop filtering.</param> public void Remove(DigitalSource input) { SetFilter(input, 0); }
/// <summary> /// Assigns the <see cref="DigitalSource"/> to this glitch filter /// </summary> /// <param name="input">The <see cref="DigitalSource"/> to add.</param> public void Add(DigitalSource input) { SetFilter(input, m_channelIndex + 1); }
public SWave_Encoder(DigitalSource Asource, DigitalSource Bsource, DigitalSource Indexsource) : base(Asource, Bsource, Indexsource) { }
/// <summary> /// Construct an Encoder given precreated A, B, and Index Channels as <see cref="DigitalSource">DigitalSources</see>. /// </summary> /// <remarks>The encoder will start counting immediately.</remarks> /// <param name="aSource">The A channel <see cref="DigitalSource"/></param> /// <param name="bSource">The B channel <see cref="DigitalSource"/></param> /// <param name="indexSource">The Index channel <see cref="DigitalSource"/></param> /// <param name="reverseDirection">True if to reverse the output, otherwise false</param> public Encoder(DigitalSource aSource, DigitalSource bSource, DigitalSource indexSource, bool reverseDirection = false) { m_allocatedA = false; m_allocatedB = false; m_allocatedI = false; if (aSource == null) throw new ArgumentNullException(nameof(aSource), "Digital Source A was null"); m_aSource = aSource; if (bSource == null) throw new ArgumentNullException(nameof(bSource), "Digital Source B was null"); m_aSource = aSource; m_bSource = bSource; m_indexSource = indexSource; InitEncoder(reverseDirection); SetIndexSource(indexSource); }
public override void Dispose() { UpdateWhenEmpty = true; ClearUpSource(); ClearDownSource(); int status = 0; FreeCounter(m_counter, ref status); CheckStatus(status); m_upSource = null; m_downSource = null; m_counter = IntPtr.Zero; }
public Encoder(DigitalSource aSource, DigitalSource bSource, bool reverseDirection, EncodingType encodingType) { m_allocatedA = false; m_allocatedB = false; m_allocatedI = false; m_encodingType = encodingType; if (aSource == null) throw new NullReferenceException("Digital Source A was null"); m_aSource = aSource; if (bSource == null) throw new NullReferenceException("Digital Source B was null"); m_aSource = aSource; m_bSource = bSource; InitEncoder(reverseDirection); }
public void SetDownSource(DigitalSource source) { if (m_downSource != null && m_allocatedDownSource) { m_downSource.Dispose(); m_allocatedDownSource = false; } m_downSource = source; int status = 0; SetCounterDownSource(m_counter, (uint)source.ChannelForRouting, source.AnalogTriggerForRouting, ref status); CheckStatus(status); }
public Encoder(DigitalSource aSource, DigitalSource bSource, DigitalSource indexSource, bool reverseDirection) { m_allocatedA = false; m_allocatedB = false; m_allocatedI = false; if (aSource == null) throw new NullReferenceException("Digital Source A was null"); m_aSource = aSource; if (bSource == null) throw new NullReferenceException("Digital Source B was null"); m_aSource = aSource; m_bSource = bSource; m_indexSource = indexSource; InitEncoder(reverseDirection); SetIndexSource(indexSource); }
/// <summary> /// Construct a <see cref="GearTooth"/> sensor given a <see cref="DigitalSource"/>. /// </summary> /// <remarks>This should be used when sharing digital inputs</remarks> /// <param name="source">An existing <see cref="DigitalSource"/> object /// (such as a <see cref="DigitalInput"/></param> /// <param name="directionSensitive">True to enable direction sensing.</param> public GearTooth(DigitalSource source, bool directionSensitive) : base(source) { DirectionSensing = directionSensitive; }
/// <summary> /// Assigns the <see cref="DigitalSource"/> to this glitch filter /// </summary> /// <param name="input">The <see cref="DigitalSource"/> to add.</param> public void Add(DigitalSource input) { SetFilter(input, m_channelIndex + 1); }
/// <summary> /// Construct a <see cref="GearTooth"/> sensor given a <see cref="DigitalSource"/>. /// </summary> /// <remarks>No direction sensing is assumed.</remarks> /// <param name="source">An existing <see cref="DigitalSource"/> object /// (such as a <see cref="DigitalInput"/></param> public GearTooth(DigitalSource source) : this(source, false) { }
public SWave_Encoder(DigitalSource Asource, DigitalSource Bsource, bool Reverse) : base(Asource, Bsource, Reverse) { }