void AnimationEffect::updateInheritedTime(double inheritedTime, TimingUpdateReason reason) const { bool needsUpdate = m_needsUpdate || (m_lastUpdateTime != inheritedTime && !(isNull(m_lastUpdateTime) && isNull(inheritedTime))) || (animation() && animation()->effectSuppressed()); m_needsUpdate = false; m_lastUpdateTime = inheritedTime; const double localTime = inheritedTime; double timeToNextIteration = std::numeric_limits<double>::infinity(); if (needsUpdate) { const double activeDuration = this->activeDurationInternal(); const Phase currentPhase = calculatePhase(activeDuration, localTime, m_timing); // FIXME: parentPhase depends on groups being implemented. const AnimationEffect::Phase parentPhase = AnimationEffect::PhaseActive; const double activeTime = calculateActiveTime(activeDuration, resolvedFillMode(m_timing.fillMode, isKeyframeEffect()), localTime, parentPhase, currentPhase, m_timing); double currentIteration; double progress; if (const double iterationDuration = this->iterationDuration()) { const double startOffset = multiplyZeroAlwaysGivesZero(m_timing.iterationStart, iterationDuration); ASSERT(startOffset >= 0); const double scaledActiveTime = calculateScaledActiveTime(activeDuration, activeTime, startOffset, m_timing); const double iterationTime = calculateIterationTime(iterationDuration, repeatedDuration(), scaledActiveTime, startOffset, m_timing); currentIteration = calculateCurrentIteration(iterationDuration, iterationTime, scaledActiveTime, m_timing); const double transformedTime = calculateTransformedTime(currentIteration, iterationDuration, iterationTime, m_timing); // The infinite iterationDuration case here is a workaround because // the specified behaviour does not handle infinite durations well. // There is an open issue against the spec to fix this: // https://github.com/w3c/web-animations/issues/142 if (!std::isfinite(iterationDuration)) progress = fmod(m_timing.iterationStart, 1.0); else progress = transformedTime / iterationDuration; if (!isNull(iterationTime)) { timeToNextIteration = (iterationDuration - iterationTime) / std::abs(m_timing.playbackRate); if (activeDuration - activeTime < timeToNextIteration) timeToNextIteration = std::numeric_limits<double>::infinity(); } } else { const double localIterationDuration = 1; const double localRepeatedDuration = localIterationDuration * m_timing.iterationCount; ASSERT(localRepeatedDuration >= 0); const double localActiveDuration = m_timing.playbackRate ? localRepeatedDuration / std::abs(m_timing.playbackRate) : std::numeric_limits<double>::infinity(); ASSERT(localActiveDuration >= 0); const double localLocalTime = localTime < m_timing.startDelay ? localTime : localActiveDuration + m_timing.startDelay; const AnimationEffect::Phase localCurrentPhase = calculatePhase(localActiveDuration, localLocalTime, m_timing); const double localActiveTime = calculateActiveTime(localActiveDuration, resolvedFillMode(m_timing.fillMode, isKeyframeEffect()), localLocalTime, parentPhase, localCurrentPhase, m_timing); const double startOffset = m_timing.iterationStart * localIterationDuration; ASSERT(startOffset >= 0); const double scaledActiveTime = calculateScaledActiveTime(localActiveDuration, localActiveTime, startOffset, m_timing); const double iterationTime = calculateIterationTime(localIterationDuration, localRepeatedDuration, scaledActiveTime, startOffset, m_timing); currentIteration = calculateCurrentIteration(localIterationDuration, iterationTime, scaledActiveTime, m_timing); progress = calculateTransformedTime(currentIteration, localIterationDuration, iterationTime, m_timing); } m_calculated.currentIteration = currentIteration; m_calculated.progress = progress; m_calculated.phase = currentPhase; m_calculated.isInEffect = !isNull(activeTime); m_calculated.isInPlay = getPhase() == PhaseActive; m_calculated.isCurrent = getPhase() == PhaseBefore || isInPlay(); m_calculated.localTime = m_lastUpdateTime; } // Test for events even if timing didn't need an update as the animation may have gained a start time. // FIXME: Refactor so that we can ASSERT(m_animation) here, this is currently required to be nullable for testing. if (reason == TimingUpdateForAnimationFrame && (!m_animation || m_animation->hasStartTime() || m_animation->paused())) { if (m_eventDelegate) m_eventDelegate->onEventCondition(*this); } if (needsUpdate) { // FIXME: This probably shouldn't be recursive. updateChildrenAndEffects(); m_calculated.timeToForwardsEffectChange = calculateTimeToEffectChange(true, localTime, timeToNextIteration); m_calculated.timeToReverseEffectChange = calculateTimeToEffectChange(false, localTime, timeToNextIteration); } }
void spintronicsStateMachine() { volatile _Q15 bridgeSample; volatile _Q15 coilSample; static unsigned char state = IDLE; static uint32_t timer; static uint8_t sensor; _Q15 cosOmega1T;//fractions of full-scale //aligned to compensate for ADCDAC_GROUP_DELAY _Q15 cosOmega2T;//fractions of full-scale //aligned to compensate for ADCDAC_GROUP_DELAY static _Q15 cosOmega1TTimeAligned;//fractions of full-scale static _Q15 cosOmega2TTimeAligned;//fractions of full-scale static _Q15 freqT[6];//array contents: 2*f1*t, 2*f2*t, 2*f1*(t + ADCDAC_GROUP_DELAY), 2*f2*(t + ADCDAC_GROUP_DELAY), 2*fdiff*(t + ADCDAC_GROUP_DELAY), 2*fsum*(t + ADCDAC_GROUP_DELAY) static int64_t cosAccumulator[5]; static int64_t sinAccumulator[5]; static _Q15 phaseAngle[5];//units are radians divided by PI static _Q15 amplitude[5];//fractions of full-scale static bool bridgeADCClipFlag; static bool coilADCClipFlag; static bool bridgeDigitalClipFlag; #ifdef SIMULATION_MODE uint16_t RXBUF2 = rand();//only to give random stimulus during simulation #endif if (RXBUF0 == 0x7FFF || RXBUF0 == 0x8000) { bridgeADCClipFlag = true; } if (RXBUF2 == 0x7FFF || RXBUF2 == 0x8000) { coilADCClipFlag = true; } bridgeSample = readBridgeSampleAndApplyGain(&bridgeDigitalClipFlag); coilSample = RXBUF2; if (GUIRequestingRun == false) { state = IDLE; } switch (state) { case IDLE: timer = 0; sensor = 0; configSensor(sensor); signalGenerator(RESET, freqT, &cosOmega1T, &cosOmega2T); shiftRegister(cosOmega1T, cosOmega2T, &cosOmega1TTimeAligned, &cosOmega2TTimeAligned); cosAccumulator[0] = 0; cosAccumulator[1] = 0; cosAccumulator[2] = 0; cosAccumulator[3] = 0; cosAccumulator[4] = 0; sinAccumulator[0] = 0; sinAccumulator[1] = 0; sinAccumulator[2] = 0; sinAccumulator[3] = 0; sinAccumulator[4] = 0; phaseAngle[0] = 0; phaseAngle[1] = 0; phaseAngle[2] = 0; phaseAngle[3] = 0; phaseAngle[4] = 0; amplitude[0] = 0; amplitude[1] = 0; amplitude[2] = 0; amplitude[3] = 0; amplitude[4] = 0; bridgeADCClipFlag = false; coilADCClipFlag = false; bridgeDigitalClipFlag = false; #ifdef CS4272_CONTROL_PORT_MODE state = CALIBRATE_ADC; enableADCHpf(true);//enable the hpf to calibrate for systematic DC offset #else state = START_SIGNAL_GEN; #endif break; #ifdef CS4272_CONTROL_PORT_MODE case CALIBRATE_ADC: signalGenerator(RESET, freqT, &cosOmega1T, &cosOmega2T); shiftRegister(cosOmega1T, cosOmega2T, &cosOmega1TTimeAligned, &cosOmega2TTimeAligned); ++timer; if (timer == ADC_CALIBRATION_TIME) { timer = 0; state = WAIT_FOR_HPF_DISABLE_MESSAGE_TX; enableADCHpf(false);//DC calibration complete; disable hpf } break; case WAIT_FOR_HPF_DISABLE_MESSAGE_TX: signalGenerator(RESET, freqT, &cosOmega1T, &cosOmega2T); shiftRegister(cosOmega1T, cosOmega2T, &cosOmega1TTimeAligned, &cosOmega2TTimeAligned); ++timer; if (timer == CS4272_SPI_TX_LATENCY) { timer = 0; state = START_SIGNAL_GEN; } break; #endif case START_SIGNAL_GEN: signalGenerator(RUN, freqT, &cosOmega1T, &cosOmega2T); shiftRegister(cosOmega1T, cosOmega2T, &cosOmega1TTimeAligned, &cosOmega2TTimeAligned); ++timer; if (timer == SETUP_TIME) { timer = 0; state = MEASURE_PHASE; } break; case MEASURE_PHASE: measurePhase(bridgeSample, coilSample, freqT, cosOmega1TTimeAligned, cosOmega2TTimeAligned, cosAccumulator, sinAccumulator); signalGenerator(RUN, freqT, &cosOmega1T, &cosOmega2T); shiftRegister(cosOmega1T, cosOmega2T, &cosOmega1TTimeAligned, &cosOmega2TTimeAligned); ++timer; if (timer == phaseMeasurementTime) { timer = 0; state = CALCULATE_PHASE; } break; case CALCULATE_PHASE: { static uint8_t shiftAmt[5]; if (timer < 5) { calculateShiftAmount(timer, cosAccumulator, sinAccumulator, shiftAmt); } else { calculatePhase(timer - 5, cosAccumulator, sinAccumulator, phaseAngle, shiftAmt); } signalGenerator(RUN, freqT, &cosOmega1T, &cosOmega2T); shiftRegister(cosOmega1T, cosOmega2T, &cosOmega1TTimeAligned, &cosOmega2TTimeAligned); ++timer; if (timer == 10) { cosAccumulator[0] = 0; cosAccumulator[1] = 0; cosAccumulator[2] = 0; cosAccumulator[3] = 0; cosAccumulator[4] = 0; sinAccumulator[0] = 0; sinAccumulator[1] = 0; sinAccumulator[2] = 0; sinAccumulator[3] = 0; sinAccumulator[4] = 0; timer = 0; state = MEASURE_AMPLITUDE; } break; } case MEASURE_AMPLITUDE: measureAmplitude(bridgeSample, coilSample, freqT, cosAccumulator, phaseAngle); signalGenerator(RUN, freqT, &cosOmega1T, &cosOmega2T); shiftRegister(cosOmega1T, cosOmega2T, &cosOmega1TTimeAligned, &cosOmega2TTimeAligned); ++timer; if (timer == amplitudeMeasurementTime) { timer = 0; state = CALCULATE_AMPLITUDE; } break; case CALCULATE_AMPLITUDE: calculateAmplitude(timer, cosAccumulator, amplitude); signalGenerator(RUN, freqT, &cosOmega1T, &cosOmega2T); shiftRegister(cosOmega1T, cosOmega2T, &cosOmega1TTimeAligned, &cosOmega2TTimeAligned); ++timer; if (timer == 5) { uint8_t index; uint8_t txSensor;//temporary variable to store the value for transmission _Q15 txPhaseAngle[5];//temporary array to store values for transmission _Q15 txAmplitude[5];//temporary array to store values for transmission bool txBridgeADCClipFlag;//temporary variable to store the flag for transmission bool txCoilADCClipFlag;//temporary variable to store the flag for transmission bool txBridgeDigitalClipFlag;//temporary variable to store the flag for transmission //store variables for transmission txSensor = sensor; for (index = 0; index < 5; ++index) { txPhaseAngle[index] = phaseAngle[index]; txAmplitude[index] = amplitude[index]; } txBridgeADCClipFlag = bridgeADCClipFlag; txCoilADCClipFlag = coilADCClipFlag; txBridgeDigitalClipFlag = bridgeDigitalClipFlag; //clear static variables for next iteration of the state machine cosAccumulator[0] = 0; cosAccumulator[1] = 0; cosAccumulator[2] = 0; cosAccumulator[3] = 0; cosAccumulator[4] = 0; timer = 0; bridgeADCClipFlag = false; coilADCClipFlag = false; bridgeDigitalClipFlag = false; state = START_SIGNAL_GEN; ++sensor; if (sensor == NUMBER_OF_SENSORS) { sensor = 0; } configSensor(sensor); //transmit results transmitResults(txSensor, txPhaseAngle, txAmplitude, txBridgeADCClipFlag, txCoilADCClipFlag, txBridgeDigitalClipFlag);//don't do this until the state machine is ready for the next measurment period; transmitting results takes more than one sample period. } break; default: timer = 0; sensor = 0; configSensor(sensor); signalGenerator(RESET, freqT, &cosOmega1T, &cosOmega2T); shiftRegister(cosOmega1T, cosOmega2T, &cosOmega1TTimeAligned, &cosOmega2TTimeAligned); cosAccumulator[0] = 0; cosAccumulator[1] = 0; cosAccumulator[2] = 0; cosAccumulator[3] = 0; cosAccumulator[4] = 0; sinAccumulator[0] = 0; sinAccumulator[1] = 0; sinAccumulator[2] = 0; sinAccumulator[3] = 0; sinAccumulator[4] = 0; phaseAngle[0] = 0; phaseAngle[1] = 0; phaseAngle[2] = 0; phaseAngle[3] = 0; phaseAngle[4] = 0; amplitude[0] = 0; amplitude[1] = 0; amplitude[2] = 0; amplitude[3] = 0; amplitude[4] = 0; break; } }
void AnimationNode::updateInheritedTime(double inheritedTime, TimingUpdateReason reason) const { bool needsUpdate = m_needsUpdate || (m_lastUpdateTime != inheritedTime && !(isNull(m_lastUpdateTime) && isNull(inheritedTime))); m_needsUpdate = false; m_lastUpdateTime = inheritedTime; const double localTime = inheritedTime - m_startTime; double timeToNextIteration = std::numeric_limits<double>::infinity(); if (needsUpdate) { const double activeDuration = this->activeDurationInternal(); const Phase currentPhase = calculatePhase(activeDuration, localTime, m_timing); // FIXME: parentPhase depends on groups being implemented. const AnimationNode::Phase parentPhase = AnimationNode::PhaseActive; const double activeTime = calculateActiveTime(activeDuration, resolvedFillMode(m_timing.fillMode, isAnimation()), localTime, parentPhase, currentPhase, m_timing); double currentIteration; double timeFraction; if (const double iterationDuration = this->iterationDuration()) { const double startOffset = multiplyZeroAlwaysGivesZero(m_timing.iterationStart, iterationDuration); ASSERT(startOffset >= 0); const double scaledActiveTime = calculateScaledActiveTime(activeDuration, activeTime, startOffset, m_timing); const double iterationTime = calculateIterationTime(iterationDuration, repeatedDuration(), scaledActiveTime, startOffset, m_timing); currentIteration = calculateCurrentIteration(iterationDuration, iterationTime, scaledActiveTime, m_timing); timeFraction = calculateTransformedTime(currentIteration, iterationDuration, iterationTime, m_timing) / iterationDuration; if (!isNull(iterationTime)) { timeToNextIteration = (iterationDuration - iterationTime) / std::abs(m_timing.playbackRate); if (activeDuration - activeTime < timeToNextIteration) timeToNextIteration = std::numeric_limits<double>::infinity(); } } else { const double localIterationDuration = 1; const double localRepeatedDuration = localIterationDuration * m_timing.iterationCount; ASSERT(localRepeatedDuration >= 0); const double localActiveDuration = m_timing.playbackRate ? localRepeatedDuration / std::abs(m_timing.playbackRate) : std::numeric_limits<double>::infinity(); ASSERT(localActiveDuration >= 0); const double localLocalTime = localTime < m_timing.startDelay ? localTime : localActiveDuration + m_timing.startDelay; const AnimationNode::Phase localCurrentPhase = calculatePhase(localActiveDuration, localLocalTime, m_timing); const double localActiveTime = calculateActiveTime(localActiveDuration, resolvedFillMode(m_timing.fillMode, isAnimation()), localLocalTime, parentPhase, localCurrentPhase, m_timing); const double startOffset = m_timing.iterationStart * localIterationDuration; ASSERT(startOffset >= 0); const double scaledActiveTime = calculateScaledActiveTime(localActiveDuration, localActiveTime, startOffset, m_timing); const double iterationTime = calculateIterationTime(localIterationDuration, localRepeatedDuration, scaledActiveTime, startOffset, m_timing); currentIteration = calculateCurrentIteration(localIterationDuration, iterationTime, scaledActiveTime, m_timing); timeFraction = calculateTransformedTime(currentIteration, localIterationDuration, iterationTime, m_timing); } m_calculated.currentIteration = currentIteration; m_calculated.timeFraction = timeFraction; m_calculated.phase = currentPhase; m_calculated.isInEffect = !isNull(activeTime); m_calculated.isInPlay = phase() == PhaseActive && (!m_parent || m_parent->isInPlay()); m_calculated.isCurrent = phase() == PhaseBefore || isInPlay() || (m_parent && m_parent->isCurrent()); m_calculated.localTime = m_lastUpdateTime - m_startTime; } // Test for events even if timing didn't need an update as the player may have gained a start time. // FIXME: Refactor so that we can ASSERT(m_player) here, this is currently required to be nullable for testing. if (reason == TimingUpdateForAnimationFrame && (!m_player || m_player->hasStartTime() || m_player->paused())) { if (m_eventDelegate) m_eventDelegate->onEventCondition(this); } if (needsUpdate) { // FIXME: This probably shouldn't be recursive. updateChildrenAndEffects(); m_calculated.timeToForwardsEffectChange = calculateTimeToEffectChange(true, localTime, timeToNextIteration); m_calculated.timeToReverseEffectChange = calculateTimeToEffectChange(false, localTime, timeToNextIteration); } }