private void SendByte(byte data) { // Send one bit at a time, starting with the MSB for (byte i = 0; i < 8; i++) { // If MSB is 1, write one and clock it, else write 0 and clock if ((data & 0x80) != 0) { dataPin.Write(true); } else { dataPin.Write(false); } // clk(): clockPin.Write(false); HighResolutionTimer.Sleep(0.02m); clockPin.Write(true); HighResolutionTimer.Sleep(0.02m); // Advance to the next bit to send data <<= 1; } }
/// <summary> /// Dibuja el contador de FPS si esta activo /// </summary> protected void RenderFPS() { if (FPS) { DrawText.drawText(HighResolutionTimer.FramesPerSecondText(), 0, 0, Color.Yellow); } }
public void MultipleSamples() { HighResolutionTimer timer = new HighResolutionTimer(); TimerSample sample1 = HighResolutionTimer.Sample(); double elapsedTime1 = Wait(); TimerSample sample2 = HighResolutionTimer.Sample(); double elapsedTime2 = Wait(); TimerSample sample3 = HighResolutionTimer.Sample(); double duration1 = HighResolutionTimer.Duration(sample1, sample2) * TimeToMilliseconds; Console.WriteLine("1 -> DateTime time: {0:N3}, Timer time: {1:N3}", elapsedTime1, duration1); Assert.Between( duration1, elapsedTime1 * (1.0 - Variation), elapsedTime1 * (1.0 + Variation) ); double duration2 = HighResolutionTimer.Duration(sample2, sample3) * TimeToMilliseconds; Console.WriteLine("2 -> DateTime time: {0:N3}, Timer time: {1:N3}", elapsedTime2, duration2); Assert.Between( duration2, elapsedTime1 * (1.0 - Variation), elapsedTime1 * (1.0 + Variation) ); }
public void ConvertTime() { HighResolutionTimer timer = new HighResolutionTimer(); timer.Start(); Wait(); timer.Stop(); double duration = timer.Duration(1); Assert.Between( HighResolutionTimer.TimeToMilliseconds(duration), duration * TimeToMilliseconds * (1.0 - Variation), duration * TimeToMilliseconds * (1.0 + Variation) ); Assert.Between( HighResolutionTimer.TimeToSeconds(duration), duration * TimeToSeconds * (1.0 - Variation), duration * TimeToSeconds * (1.0 + Variation) ); Assert.Between( HighResolutionTimer.TimeToTimeSpan(duration).TotalSeconds, duration * TimeToSeconds * (1.0 - Variation), duration * TimeToSeconds * (1.0 + Variation) ); }
public SequenceExecutor() { _endCheckTimer = new HighResolutionTimer(10f); _endCheckTimer.UseHighPriorityThread = false; _endCheckTimer.Elapsed += _EndCheckTimerElapsed; _syncContext = AsyncOperationManager.SynchronizationContext; }
private ushort GetRawTemperature() { WriteByte(Interop.CONTROL, Interop.READTEMPCMD); HighResolutionTimer.Sleep(lowDelay); return(ReadUInt16(Interop.TEMPDATA)); }
private uint GetRawPressure() { WriteByte(Interop.CONTROL, (byte)(Interop.READPRESSURECMD + ((int)precision << 6))); switch (precision) { case Bmp085Precision.Low: HighResolutionTimer.Sleep(lowDelay); break; case Bmp085Precision.High: HighResolutionTimer.Sleep(highDelay); break; case Bmp085Precision.Highest: HighResolutionTimer.Sleep(highestDelay); break; default: HighResolutionTimer.Sleep(defaultDelay); break; } var msb = ReadByte(Interop.PRESSUREDATA); var lsb = ReadByte(Interop.PRESSUREDATA + 1); var xlsb = ReadByte(Interop.PRESSUREDATA + 2); var raw = ((msb << 16) + (lsb << 8) + xlsb) >> (8 - (int)precision); return((uint)raw); }
public Sender(Log log, Statistics statistics, ProgramConfiguration programConfiguration) : base(log, programConfiguration) { var destinationEndPoint = new IPEndPoint(_programConfiguration.DestinationIpAddress, programConfiguration.DestinationPort); _networkProtocol = new UdpNetworkProtocol( log, statistics, destinationEndPoint, UdpNetworkProtocolType.Udp, _programConfiguration.PacketSize, _programConfiguration.VerifyOrder); _sendDataTask = new HighResolutionTimer { Mode = TimerMode.Periodic, Period = 1000, Resolution = 0, IsAsync = true }; _sendDataTask.Tick += (sender, args) => SendData(); var bindedIp = MachineAddress.FirstOrDefault(i => i.Equals(_programConfiguration.SourceIpAddress)) ?? IPAddress.Any; var bindedPort = programConfiguration.SourcePort ?? 0; _networkProtocol.Bind(new IPEndPoint(bindedIp, bindedPort)); if (programConfiguration.NetworkBufferSize.HasValue) { _networkProtocol.SetSendBufferSize(programConfiguration.NetworkBufferSize.Value); } }
/// <summary> /// Runs this instance. /// </summary> private void Run() { var timer = new HighResolutionTimer(); var lastElapsedTime = TimeSpan.FromSeconds(0); while (IsRunning) { if (lastElapsedTime < ReadTime) { Thread.Sleep(ReadTime - lastElapsedTime); } timer.Start(); var sensorData = RetrieveSensorData(); lastElapsedTime = timer.Elapsed; if (IsRunning) { DataAvailable?.Invoke(this, sensorData); } timer.Reset(); } SetSleepMode(true); }
public static void GameLoop() { m_timer = new HighResolutionTimer(1); m_stopwatch = new Stopwatch(); m_stopwatch.Start(); m_timer.Elapsed += OnTick; m_timer.Start(); }
/// <summary> /// Starts sensor reading. /// </summary> public void Start() { TriggerPin.PinMode = GpioPinDriveMode.Output; EchoPin.PinMode = GpioPinDriveMode.Input; measurementTimer = new HighResolutionTimer(); IsRunning = true; ReadWorker.Start(); }
private void PlayGif(FFGifDrawable gifDrawable, CancellationTokenSource tokenSource) { var token = tokenSource.Token; var animatedImages = gifDrawable.AnimatedImages; _animationTimer?.Stop(); _animationTimer = new HighResolutionTimer <Android.Graphics.Bitmap>(gifDrawable.AnimatedImages, async(image) => { if (_animationFrameSetting) { return; } _animationFrameSetting = true; try { var bitmap = image.Image; if (_isDisposed || !_animationTimer.Enabled) { return; } if (bitmap != null && bitmap.Handle != IntPtr.Zero && !bitmap.IsRecycled) { if (_isDisposed || !_animationTimer.Enabled) { return; } await ImageService.Instance.Config.MainThreadDispatcher.PostAsync(() => { if (_isDisposed || !_animationTimer.Enabled) { return; } base.SetImageBitmap(bitmap); ; }).ConfigureAwait(false); } } catch (Exception ex) { ImageService.Instance.Config.Logger.Error("GIF", ex); } finally { _animationFrameSetting = false; } }) { DelayOffset = -2 }; _animationTimer.Start(); }
private void LatchData() { dataPin.Write(false); HighResolutionTimer.Sleep(delay); for (int i = 0; i < 4; i++) { dataPin.Write(true); dataPin.Write(false); } }
/// <summary> /// Senses the distance. /// </summary> public void SenseDistance() { var timer = new HighResolutionTimer(); this.EnsureReady(); _timer = new Stopwatch(); _trigPin.Write(GpioPinValue.High); timer.Sleep(0.01d); _trigPin.Write(GpioPinValue.Low); }
protected virtual void Dispose(bool disposing) { if (disposing) { if (_endCheckTimer != null) { _endCheckTimer.Elapsed -= _EndCheckTimerElapsed; _endCheckTimer = null; } } _endCheckTimer = null; _syncContext = null; }
private void InitializeTimer() { //Console.WriteLine($"IsHighResolution = {HighResolutionTimer.IsHighResolution}"); //Console.WriteLine($"Tick time length = {HighResolutionTimer.TickLength} [ms]"); // UseHighPriorityThread = true, sets the execution thread to ThreadPriority.Highest. // It doesn't provide any precision gain in most of the cases and may do things worse for other threads. // It is suggested to do some studies before setting it true _Timer = new HighResolutionTimer(30.0f) // in msec { UseHighPriorityThread = false }; _Timer.Elapsed += Timer_Elapsed; }
private static void PlayAnimation(ImageView control, ISelfDisposingAnimatedBitmapDrawable drawable) { lock (_runningAnimations) { var hashCode = control.GetHashCode(); var timer = new HighResolutionTimer <ISelfDisposingAnimatedBitmapDrawable>(drawable, async(t, bitmap) => { try { try { if (control == null || control.Handle == IntPtr.Zero || !drawable.IsValidAndHasValidBitmap()) { StopAnimation(control); return; } await ImageService.Instance.Config.MainThreadDispatcher.PostAsync(() => { if (control == null || control.Handle == IntPtr.Zero || !drawable.IsValidAndHasValidBitmap()) { StopAnimation(control); return; } control.SetImageBitmap(bitmap); }); } catch (ObjectDisposedException) { StopAnimation(control); } } catch (Exception ex) { ImageService.Instance.Config.Logger.Error("GIF", ex); } }) { DelayOffset = -2 }; _runningAnimations.Add(control, timer); timer.Start(); } }
public VariableViewForm() { InitializeComponent(); RefreshComPorts(); valuesUpdater = new SerialPortUpdater(); displayTimer = new HighResolutionTimer(200.0f); displayTimer.UseHighPriorityThread = false; displayTimer.Elapsed += displayTimer_Elapsed; SetStyle(ControlStyles.OptimizedDoubleBuffer, true); DoubleBuffered = true; }
/// <summary> /// Sets the pin resistor. /// </summary> /// <param name="pin">The pin.</param> /// <param name="resistor">The resistor.</param> public void SetPinResistor(ProcessorPin pin, PinResistor resistor) { // Set the pullup/down resistor for a pin // // The GPIO Pull-up/down Clock Registers control the actuation of internal pull-downs on // the respective GPIO pins. These registers must be used in conjunction with the GPPUD // register to effect GPIO Pull-up/down changes. The following sequence of events is // required: // 1. Write to GPPUD to set the required control signal (i.e. Pull-up or Pull-Down or neither // to remove the current Pull-up/down) // 2. Wait 150 cycles ? this provides the required set-up time for the control signal // 3. Write to GPPUDCLK0/1 to clock the control signal into the GPIO pads you wish to // modify ? NOTE only the pads which receive a clock will be modified, all others will // retain their previous state. // 4. Wait 150 cycles ? this provides the required hold time for the control signal // 5. Write to GPPUD to remove the control signal // 6. Write to GPPUDCLK0/1 to remove the clock // // RPi has P1-03 and P1-05 with 1k8 pullup resistor uint pud; switch (resistor) { case PinResistor.None: pud = Interop.BCM2835_GPIO_PUD_OFF; break; case PinResistor.PullDown: pud = Interop.BCM2835_GPIO_PUD_DOWN; break; case PinResistor.PullUp: pud = Interop.BCM2835_GPIO_PUD_UP; break; default: throw new ArgumentOutOfRangeException("resistor", resistor, string.Format(CultureInfo.InvariantCulture, "{0} is not a valid value for pin resistor", resistor)); } WriteResistor(pud); HighResolutionTimer.Sleep(resistorSetDelay); SetPinResistorClock(pin, true); HighResolutionTimer.Sleep(resistorSetDelay); WriteResistor(Interop.BCM2835_GPIO_PUD_OFF); SetPinResistorClock(pin, false); pinResistors[pin] = PinResistor.None; }
public SinglePrecisionDataChannel(int samplesPerSecond, int bufferSize) { HighResolutionTimer hrt = new HighResolutionTimer(); this.ChannelId = (int)(hrt.Value % Int32.MaxValue); System.Threading.Thread.Sleep(1); this.SamplesPerSecond = samplesPerSecond; this.BufferSize = bufferSize; this.Data = new float[bufferSize]; this.Labels = new string[bufferSize]; this.TimeStamps = new DateTime[bufferSize]; this.Quality = new float[bufferSize]; }
/// <summary> /// Performs the continuous reads of the sensor. /// This method represents the body of the worker. /// </summary> private void PerformContinuousReads() { var stopwatch = new HighResolutionTimer(); var lastElapsedTime = TimeSpan.FromSeconds(0); while (IsRunning) { try { // Start to comunicate with sensor // Inform sensor that must finish last execution and put it's state in idle DataPin.PinMode = GpioPinDriveMode.Output; // Waiting for sensor init DataPin.Write(GpioPinValue.High); if (lastElapsedTime < ReadInterval) { Thread.Sleep(ReadInterval - lastElapsedTime); } // Start to counter measure time stopwatch.Start(); // Send request to trasmission from board to sensor DataPin.Write(GpioPinValue.Low); Pi.Timing.SleepMicroseconds(1000); DataPin.Write(GpioPinValue.High); Pi.Timing.SleepMicroseconds(20); DataPin.Write(GpioPinValue.Low); // Acquire measure var sensorData = RetrieveSensorData(); OnDataAvailable?.Invoke(this, sensorData); } catch { // swallow } lastElapsedTime = stopwatch.Elapsed; if (stopwatch.IsRunning) { stopwatch.Stop(); } stopwatch.Reset(); } }
public void MeasureCallTime() { // Warm up HighResolutionTimer.Sample(); TimerSample start = HighResolutionTimer.Sample(); TimerSample end = HighResolutionTimer.Sample(); Console.WriteLine(HighResolutionTimer.Duration(start, end)); HighResolutionTimer timer = new HighResolutionTimer(); timer.Start(); timer.Stop(); Console.WriteLine(timer.Duration(1)); }
/// <summary> /// Initializes a new instance of a <see cref="ComponentTraceEventProvider"/> object using the specified provider name and its unique identity. /// </summary> /// <param name="providerName">The name of the tracing provider.</param> /// <param name="providerGuid">The unique ID of the tracing provider.</param> public ComponentTraceEventProvider(string providerName, Guid providerGuid) { Guard.ArgumentNotNullOrEmptyString(providerName, "providerName"); Guard.ArgumentNotDefaultValue <Guid>(providerGuid, "providerGuid"); this.state = TraceEventProviderState.Initializing; this.providerName = providerName; this.providerGuid = providerGuid; this.highResTimer = new HighResolutionTimer(); // Configure the trace listener and default trace options. this.debugTraceProvider = new TraceSource(providerName, SourceLevels.All); this.debugTraceProvider.Switch = new SourceSwitch(providerName); this.debugTraceProvider.Switch.Level = SourceLevels.All; this.debugTraceProvider.Listeners.Add(new DefaultTraceListener()); }
public double GetData() { Connection.Write(0x10); HighResolutionTimer.Sleep(TimeSpanUtility.FromMicroseconds(150 * 1000)); byte[] readBuf = Connection.Read(2); var valf = readBuf[0] << 8; valf |= readBuf[1]; return(valf / 1.2 * (69 / 69) / 1); // var valf = ((readBuf[0] << 8) | readBuf[1]) / 1.2; // return valf; // return Math.Round(valf / (2 * 1.2), 2); }
/// <summary> /// Initializes a new instance of the <see cref="StoredProcedure"/> class. /// </summary> /// <param name="name">The name.</param> /// <param name="connectionInfo">The cached connection string information.</param> private StoredProcedure(string name, ConnectionInfo connectionInfo) { this.connectionInfo = connectionInfo; DbCommand dbCommand = connectionInfo.ProviderFactory.CreateCommand(); dbCommand.CommandText = name; dbCommand.CommandType = CommandType.StoredProcedure; commandWrapper = new CommandWrapper(dbCommand, connectionInfo.ProviderFactory); #if (DEBUG) timer = new HighResolutionTimer(); // Build the timer timer.Start(); timer.Stop(); #endif }
public void Stop() { if (timer == null) { return; } lock (mutex) { if (timer == null) { return; } timer.Stop(); timer.Elapsed -= OnTick; timer = null; } }
private void GetMeasure() { var hrt = new HighResolutionTimer(); var lastElapsedTime = TimeSpan.FromSeconds(0); while (_started) { try { THData measure = null; //Start to comunicate with sensor //Inform sensor that must finish last execution and put it's state in idle _pin.PinMode = GpioPinDriveMode.Output; //Waiting for sensor init _pin.Write(GpioPinValue.High); if (lastElapsedTime < _measureTime) { Thread.Sleep(_measureTime - lastElapsedTime); } //Start to counter measure time hrt.Start(); //Send request to trasmission from board to sensor _pin.Write(GpioPinValue.Low); _timing.SleepMicroseconds(1000); _pin.Write(GpioPinValue.High); _timing.SleepMicroseconds(20); _pin.Write(GpioPinValue.Low); //Acquire measure measure = TryGetMeasure(); OnSensorRead(measure); } catch { //ignored } lastElapsedTime = hrt.Elapsed; if (hrt.IsRunning) { hrt.Stop(); } hrt.Reset(); } }
public void Start() { if (timer != null) { return; } lock (mutex) { if (timer != null) { return; } timer = new HighResolutionTimer(intervalInMilliseconds); timer.Elapsed += OnTick; ellapsedTicks = 0; timer.Start(); } }
public void StartStop() { HighResolutionTimer timer = new HighResolutionTimer(); timer.Start(); double elapsedTime = Wait(); timer.Stop(); double duration = timer.Duration(1) * TimeToMilliseconds; Console.WriteLine("DateTime time: {0:N3}, Timer time: {1:N3}", elapsedTime, duration); Assert.Between( duration, elapsedTime * (1.0 - Variation), elapsedTime * (1.0 + Variation) ); }
public TgcExample(string mediaDir, string shadersDir) { //TgcAxisLines axisLines, TgcCamera camara MediaDir = mediaDir; ShadersDir = shadersDir; AxisLines = new TgcAxisLines(); AxisLinesEnable = true; FPS = true; Camara = new TgcCamera(); ElapsedTime = -1; HighResolutionTimer = new HighResolutionTimer(); Frustum = new TgcFrustum(); //DirectSound = new TgcDirectSound(); Por ahora se carga por afuera DrawText = new TgcText2D(); Input = new TgcD3dInput(); Category = "Others"; Name = "Ejemplo en Blanco"; Description = "Ejemplo en Blanco. Es hora de empezar a hacer tu propio ejemplo :)"; }
/// <summary> /// Crea un ejemplo con lo necesario para realizar un juego. /// </summary> /// <param name="mediaDir">Ruta donde estan los Media.</param> /// <param name="shadersDir">Ruta donde estan los Shaders.</param> public TGCExample(string mediaDir, string shadersDir) { MediaDir = mediaDir; ShadersDir = shadersDir; AxisLines = new TgcAxisLines(); AxisLinesEnable = true; FPSText = true; TimeBetweenRenders = 1F / FPS_60; TimeBetweenUpdates = 1F / FPS_60; LastRenderTime = 0; LastUpdateTime = 0; ElapsedTime = -1; Camera = new TgcCamera(); Timer = new HighResolutionTimer(); Frustum = new TgcFrustum(); //DirectSound = new TgcDirectSound(); Por ahora lo carga el Model DrawText = new TgcText2D(); //Input = new TgcD3dInput(); Por ahora lo carga el Model BackgroundColor = DefaultClearColor; Category = "Others"; Name = "Ejemplo en Blanco"; Description = "Ejemplo en Blanco. Es hora de empezar a hacer tu propio ejemplo :)"; }