void Update() { if (TimeCounter > 0 && playerShip.Won == false) { TimeCounter -= Time.deltaTime; TimeOnScreen = Mathf.Floor(TimeCounter); TimeText.text = "Time: " + TimeOnScreen; if (playerShip != null && TimeCounter <= 0f) { playerShip.Kill(); YouLoseText.enabled = true; DelayHelper.DelayAction(this, ReloadLevel, 5.0f); } } else if (TimeCounter <= 0) { TimeText.text = "Time: " + 0; } if (Input.GetKeyDown(KeyCode.Backspace)) { ReloadLevel(); } if (Input.GetKeyDown(KeyCode.Escape)) { Application.Quit(); } }
//==================================================================== void Update() { if (null != helperList) { for (int i = 0; i < helperList.Count(); ++i) { DelayHelper helper = helperList[i]; helper.delay -= UnityEngine.Time.deltaTime; if (helper.delay <= 0) { helperList.RemoveAt(i); i--; helper.Invoke(); } } } if (null != unscaledHelperList) { for (int i = 0; i < unscaledHelperList.Count(); ++i) { DelayHelper helper = unscaledHelperList[i]; helper.delay -= UnityEngine.Time.unscaledDeltaTime; if (helper.delay <= 0) { unscaledHelperList.RemoveAt(i); i--; helper.Invoke(); } } } }
/// <summary> /// Reads previous reading and prepares next reading for specified channel /// </summary> /// <param name="channelToCharge">Channel to prepare</param> /// <returns>10 bit value corresponding to relative voltage level on channel</returns> public int ReadPreviousAndChargeChannel(Channel channelToCharge) { if (!IsValidChannel(channelToCharge)) { throw new ArgumentOutOfRangeException(nameof(channelToCharge)); } Span <byte> readBuffer = stackalloc byte[2]; Span <byte> writeBuffer = stackalloc byte[2]; writeBuffer[0] = (byte)((int)channelToCharge << 1); _spiDevice.TransferFullDuplex(writeBuffer, readBuffer); int previousReading = ((readBuffer[0] & 0b11111) << 5) | (readBuffer[1] & 0b11111); if (_endOfConversion != -1) { // Wait for ADC to report end of conversion or timeout at max conversion time _controller.WaitForEvent(_endOfConversion, PinEventTypes.Rising, _conversionTime); } else { // Max conversion time (21us) as seen in table on page 10 in TLC1543 documentation DelayHelper.Delay(_conversionTime, false); } return(previousReading); }
/// <summary> /// Write a PiJuice command /// </summary> /// <param name="command">The PiJuice command</param> /// <param name="data">The data to write</param> internal void WriteCommand(PiJuiceCommand command, ReadOnlySpan <byte> data) { byte tries = 0; Span <byte> buffer = stackalloc byte[data.Length + 2]; data.CopyTo(buffer.Slice(1)); buffer[0] = (byte)command; buffer[buffer.Length - 1] = GetCheckSum(data, checkLastByte: true); // When writing/reading to the I2C port, PiJuice doesn't respond on time in some cases // So we wait a little bit before retrying // In most cases, the I2C read/write can go thru without waiting while (tries < MaxRetries) { try { _i2cDevice.Write(buffer); return; } catch (IOException ex) { tries++; if (tries >= MaxRetries) { throw new IOException($"{nameof(WriteCommand)}: Failed to write command {command}", ex); } DelayHelper.DelayMilliseconds(ReadRetryDelay, false); } } }
public async Task <RoundResult> PerformNextRoundAsync() { _roundNumber++; _movementService.ExpiryExplosions(); await DelayHelper.DelayAsync(_delayTime); _movementService.PerformMissilesMove(); await DelayHelper.DelayAsync(_delayTime); //call winner if (_antWarsViewModel.MovableObjectsCollection.OfType <AntModel>().Count() <= 1) { return(new RoundResult { FinalResult = _botService.GetBotResults(), IsFinished = true, History = new List <RoundPartialHistory>() }); } var partialResults = await _movementService.PlayAntsMoveAsync(200, _roundNumber); return(new RoundResult { FinalResult = null, IsFinished = false, History = partialResults, }); }
private byte Read_byte(byte register) { Change_register(register); DelayHelper.DelayMilliseconds(10, allowThreadYield: true); return(_device.ReadByte()); }
public static void IrTest(List <string> argsList, IrReceiver ir) { Console.WriteLine($"Ir Test"); double delay; if (argsList.Count > 1) { delay = Convert.ToDouble(argsList[1]); } else { delay = 10; } while (true) { int data = ir.GetKey(); if (data == 0 & data != 999) { Console.Write($"_"); } else if (data == 999) { Console.WriteLine($"data: repeated last"); } else { Console.WriteLine($"data: {data} "); } DelayHelper.DelayMilliseconds((int)delay, true); } }
public static void MotorTest(List <string> argsList, DCMotor motorL, DCMotor motorR) { double delay; if (argsList.Count > 1) { delay = Convert.ToDouble(argsList[1]); } else { delay = 10; } const double Period = 20.0; Console.WriteLine($"Motor Test"); Stopwatch sw = Stopwatch.StartNew(); string lastSpeedDisp = null; while (sw.ElapsedMilliseconds < (Math.PI * 2000)) { double time = sw.ElapsedMilliseconds / 1000.0; // Note: range is from -1 .. 1 (for 1 pin setup 0 .. 1) motorL.Speed = Math.Sin(2.0 * Math.PI * time / Period); motorR.Speed = Math.Sin(2.0 * Math.PI * time / Period); string disp = $"Speed[L, R] = [{motorL.Speed:0.00}, {motorR.Speed:0.00}]"; if (disp != lastSpeedDisp) { lastSpeedDisp = disp; Console.WriteLine(disp); } DelayHelper.DelayMilliseconds((int)delay, true); } }
public static void AdcTest(List <string> argsList, Tlc1543 adc) { Console.WriteLine($"ADC Test"); double delay; byte sensorNumber; if (argsList.Count > 1) { delay = Convert.ToDouble(argsList[1]); } else { delay = 10; } if (argsList.Count > 2) { sensorNumber = Convert.ToByte(argsList[2]); } else { sensorNumber = 11; } while (true) { for (int i = 0; i < sensorNumber; i++) { Console.Write($"{i}: {adc.ReadChannel((Tlc1543.Channel)i),4} "); DelayHelper.DelayMilliseconds((int)delay, true); } Console.WriteLine(); } }
public void TakeDamage(int damage) { Health -= damage; Debug.Log("Health for " + this.transform.name + " is " + Health); HitCircle.color = Color.red; DelayHelper.DelayAction(this, swapToWhite, .7f); bool deathnoise = false; if (Health <= 0) { if (deathnoise == false) { EnemyAudio.clip = AudioExploding; EnemyAudio.Play(); deathnoise = true; Exploder.Play(); PLC.UpdateHealth(1); } DisableObject(); Debug.Log(this.transform.name + " is " + "dead"); LV.IncreaseScore(5); if (IsFreezeOn == true) { LV.IncreaseScore(5); } } }
public void UpdateHealth(int HPupdate) { if (IsImmune == false) { if (HPupdate < 0) { HP += HPupdate; AudioHits.clip = AudioDamaged; AudioHits.Play(); RedBoxLeft.enabled = true; RedBoxRight.enabled = true; RedBoxLeft.CrossFadeAlpha(0, .5f, false); RedBoxRight.CrossFadeAlpha(0, .5f, false); DelayHelper.DelayAction(this, Resetboxes, .5f); } if (HPupdate > 0) { if (HP < 5) { HP += HPupdate; } } int HealhGUISize = HP * 100; HealthGUI.rectTransform.sizeDelta = new Vector2(HealhGUISize, 50); } }
/// <summary> /// Calibrates the probe using a single point using a mV value. /// </summary> /// <param name="solutionmV">mV value</param> public void CalibrateSingle(float solutionmV) { Write_register((byte)Register.ISE_SOLUTION_REGISTER, solutionmV); Send_command((byte)Command.ISE_CALIBRATE_SINGLE); DelayHelper.DelayMilliseconds(ISE_MV_MEASURE_TIME, allowThreadYield: true); }
//==================================================================== void Update() { if (null != m_lstHelper) { for (int i = 0; i < m_lstHelper.Count(); ++i) { DelayHelper helper = m_lstHelper[i]; helper.delay -= UnityEngine.Time.deltaTime; if (helper.delay <= 0) { m_lstHelper.RemoveAt(i); i--; helper.Invoke(); } } } if (null != m_lstUnscaledHelper) { for (int i = 0; i < m_lstUnscaledHelper.Count(); ++i) { DelayHelper helper = m_lstUnscaledHelper[i]; helper.delay -= UnityEngine.Time.unscaledDeltaTime; if (helper.delay <= 0) { m_lstUnscaledHelper.RemoveAt(i); i--; helper.Invoke(); } } } }
private void CancelInvokeWorker(object group) { if (null != helperList) { if (group == null) { for (int i = 0; i < helperList.Count; i++) { helperList[i] = null; } helperList.Clear(); return; } for (int i = 0; i < helperList.Count(); ++i) { DelayHelper helper = helperList[i]; if (helper.group == group) { helperList.RemoveAt(i); i--; } } } }
public async override void Execute(object parameter = null) { _viewModel.IsGameInProgress = true; if (_viewModel.IsGamePaused) { _viewModel.IsGamePaused = false; await _viewModel.ResumeGameAsync(); await DelayHelper.DelayAsync(_viewModel.ArenaConfiguration.GameConfiguration.NextMatchDelay); } while (_viewModel.Elimination.GetNextCompetitors() != null && _viewModel.IsGameInProgress) { await _viewModel.PlayNextGameAsync(); await DelayHelper.DelayAsync(_viewModel.ArenaConfiguration.GameConfiguration.NextMatchDelay); } _viewModel.IsGameInProgress = false; if (_viewModel.ShouldRestartGame) { _viewModel.RestartGame(); } }
private void StartTransmission() { _controller.Write(_pinClk, PinValue.High); _controller.Write(_pinDio, PinValue.High); DelayHelper.DelayMicroseconds(ClockWidthMicroseconds, true); _controller.Write(_pinDio, PinValue.Low); }
/// <summary> /// Initializes the bit mode settings. /// </summary> protected override void InitializeBitMode() { // Prep the pins _controller.OpenPin(_rsPin, PinMode.Output); if (_rwPin != -1) { _controller.OpenPin(_rwPin, PinMode.Output); } if (_backlight != -1) { _controller.OpenPin(_backlight, PinMode.Output); if (_backlightBrightness > 0) { // Turn on the backlight _controller.Write(_backlight, PinValue.High); } } _controller.OpenPin(_enablePin, PinMode.Output); for (int i = 0; i < _dataPins.Length; ++i) { _controller.OpenPin(_dataPins[i], PinMode.Output); } // The HD44780 self-initializes when power is turned on to the following settings: // // - 8 bit, 1 line, 5x7 font // - Display, cursor, and blink off // - Increment with no shift // // It is possible that the initialization will fail if the power is not provided // within specific tolerances. As such, we'll always perform the software based // initialization as described on pages 45/46 of the HD44780 data sheet. We give // a little extra time to the required waits. if (_dataPins.Length == 8) { // Init to 8 bit mode DelayHelper.DelayMilliseconds(50, allowThreadYield: true); Send(0b0011_0000); DelayHelper.DelayMilliseconds(5, allowThreadYield: true); Send(0b0011_0000); DelayHelper.DelayMicroseconds(100, allowThreadYield: true); Send(0b0011_0000); } else { // Init to 4 bit mode, setting _rspin to low as we're writing 4 bits directly. // (Send writes the whole byte in two 4bit/nybble chunks) _controller.Write(_rsPin, PinValue.Low); DelayHelper.DelayMilliseconds(50, allowThreadYield: true); WriteBits(0b0011, 4); DelayHelper.DelayMilliseconds(5, allowThreadYield: true); WriteBits(0b0011, 4); DelayHelper.DelayMicroseconds(100, allowThreadYield: true); WriteBits(0b0011, 4); WriteBits(0b0010, 4); } }
public async Task <RoundResult> PerformNextRoundAsync() { if (Player1 == null || Player2 == null) { throw new Exception("There are no players to perform next round."); } var result = new RoundResult() { History = new List <RoundPartialHistory>(), IsFinished = false }; foreach (var competitor in _competitors) { if (IsBoardFull()) { ClearTheBoard(); } result.History.Add(await PerformNextMove(competitor)); await DelayHelper.DelayAsync(_configuration.NextMoveDelay); if (await IsPlayerWon(competitor)) { result.IsFinished = true; result.FinalResult = GetResults(); break; } } return(result); }
public async Task HandleExplodablesAsync(int explosionDisplayTime) { _field.Explosions.Clear(); foreach (var missile in _field.Missiles) { HandleMissileMovement(missile); } foreach (var bomb in _field.Bombs) { bomb.RoundsUntilExplodes--; if (!bomb.IsExploded && bomb.RoundsUntilExplodes == 0) { SetExplosion(bomb); } } _field.Bombs.RemoveAll(bomb => bomb.IsExploded); _field.Missiles.RemoveAll(missile => missile.IsExploded); _field.OnArenaChanged(); await DelayHelper.DelayAsync(explosionDisplayTime); _field.Explosions.Clear(); }
private void CancelInvokeWorker(object group) { if (null != m_lstHelper) { if (group == null) { for (int i = 0; i < m_lstHelper.Count; i++) { m_lstHelper[i] = null; } m_lstHelper.Clear(); return; } for (int i = 0; i < m_lstHelper.Count(); ++i) { DelayHelper helper = m_lstHelper[i]; if (helper.group == group) { m_lstHelper.RemoveAt(i); i--; } } } }
private void Write_byte(byte register, byte value) { Change_register(register); _device.WriteByte(value); DelayHelper.DelayMilliseconds(10, allowThreadYield: true); }
private async Task SetArenaMessage(string message) { ArenaMessage = message; IsArenaMessageVisible = true; await DelayHelper.DelayAsync(ArenaConfiguration.ArenaMessageDuration); IsArenaMessageVisible = false; }
private void Update() { if (Input.GetKeyDown(KeyCode.Space)) { Resume(); DelayHelper.DelayAction(this, Pause, 0.1f); } }
/// <summary> /// Create a DHT10 sensor through I2C /// </summary> /// <param name="i2cDevice">I2C Device</param> public Dht10(I2cDevice i2cDevice) : base(i2cDevice) { i2cDevice.WriteByte(DHT10_CMD_SOFTRESET); // make sure DHT10 stable (in the datasheet P7) DelayHelper.DelayMilliseconds(20, true); i2cDevice.WriteByte(DHT10_CMD_INIT); }
private void Send_command(byte data) { Span <byte> bytes = stackalloc byte[2]; bytes[0] = (byte)Register.ISE_TASK_REGISTER; bytes[1] = data; _device.Write(bytes); DelayHelper.DelayMilliseconds(10, allowThreadYield: true); }
private void WakeUpDevice() { if (_pinWake >= 0) { _controller.Write(_pinWake, PinValue.Low); // Doc says wait 50 micro seconds DelayHelper.DelayMicroseconds(50, true); } }
private void SleepDownDevice() { if (_pinWake >= 0) { _controller.Write(_pinWake, PinValue.High); // Doc says wait 20 micro seconds DelayHelper.DelayMicroseconds(50, true); } }
/// <summary> /// Initializes the bit mode settings. /// </summary> protected override void InitializeBitMode() { // Init to 8 bit mode DelayHelper.DelayMilliseconds(50, allowThreadYield: true); Send(0b0011_0000); DelayHelper.DelayMilliseconds(5, allowThreadYield: true); Send(0b0011_0000); DelayHelper.DelayMicroseconds(100, allowThreadYield: true); Send(0b0011_0000); }
//FIRE PROJECTILE void Shoot() { //create projectile Instantiate(confuseProjectile, projectileSpawnPoint.position, transform.rotation, projectileParent); //play projectile effects PlayShootFeedback(); //prevents from shooting again until DelayAction marks the ship as reloaded canFire = false; DelayHelper.DelayAction(this, ReadyToFire, projectileReloadTime); }
internal override void ReadThroughI2c() { // DHT10 has no calibration bits IsLastReadSuccessful = true; _i2cDevice.WriteByte(DHT10_CMD_START); // make sure DHT10 ends measurement (in the datasheet P7) DelayHelper.DelayMilliseconds(75, true); _i2cDevice.Read(_dht10ReadBuff); }