# OSC Signalling Conditions there are some Verifications For signals. here i described them. ## Long - OSC - When Market Middleage Cross Over MC Fast - When MCFast Under MC Slow - When MakretMiddleage ```mql4 // // // // XMA Based Signals ... // hasLongSignal = // // // // XMA ... // // // // SC Fast Cross Over Market Middleage ... // xmaState.scFast > xmaState.marketMiddleage // && !(xmaState.scFastPrev > xmaState.marketMiddleage) // // // // when Short Cycle is Trending Up ... // && xmaState.scFast > xmaState.scSlow // && xmaState.scFastPrev > xmaState.scSlowPrev // // // // When Medium Cycle is Trending Up ... // && xmaState.mcFast > xmaState.mcSlow // && xmaState.mcFastPrev > xmaState.mcSlowPrev // // // // and Medium Cycle TrendPower is Going Up ... // && MathAbs(xmaState.mcFast - xmaState.mcSlow) > // MathAbs(xmaState.mcFastPrev - xmaState.mcSlowPrev) // // // // When Long Cycle is Trending Up ... // && xmaState.lcFast > xmaState.lcSlow // && xmaState.lcFastPrev > xmaState.lcSlowPrev // // // // and Long Cycle TrendPower is Going Up ... // && MathAbs(xmaState.lcFast - xmaState.lcSlow) > // MathAbs(xmaState.lcFastPrev - xmaState.lcSlowPrev) // // // // Short Cycle Slow bigger thhan Medium Cycle Fast ... // && xmaState.scSlow > xmaState.mcFast // // // // OSC ... // // Check OSC Fast and Slow is Less than 0.5 ... // && oscState.fastOSC < 0.5 // && oscState.slowOSC < 0.5 // && oscState.fastOSCPrev < 0.5 // && oscState.slowOSCPrev < 0.5 // && oscState.fastOSC > oscState.fastOSCPrev // // // // Check OSC Minimum Signal Power ... // // this Helps for Detect Market exits from Ranging ... // && minPowOSC > 0 // ? // // // // Check Conditions only if value provided ... // oscState.powerOSCPrev < 0 // && MathAbs(oscState.powerOSCPrev) > minPowOSC // : // // // // ... other wise, ignore ... // true // // // // Check Previous Candle Signal Power must be Lower than // // Current Signal Power and the Direction Must be Up Trend ... // && oscState.powerOSCPrev < oscState.powerOSC // // // // Also we Have to Check Market not ranging ... // && !IsOSCMarketRanging( // bar_index + 1, // marketLen, // minPowOSC, // fastOSCLen, // fastOSCMul, // slowOSCLen, // slowOSCMul // ) // // // // ZIGZAG ... // && zigZagState.isWaitForTrendDown // && !zigZagState.isWaitForTrendUp // // // // XADX ... // // TODO: add XADX Base Conditions for Long Trades ... // // When ADX Trend Power bigger than 20 and less than 50 ... // && !adxState.trendPower < 23 // && !adxState.trendPowerPrev < 23 // // // // Check Trend Direction for Signals ... // && adxState.upDirection > adxState.downDirection // && adxState.upDirectionPrev > adxState.downDirectionPrev // // && adxState.trendPower < 50 // // && adxState.trendPower > adxState.trendPowerPrev // // // // PRICE Checking ... // // price must be less than Candle High at openning time ... // && longEntryPrice <= candleHigh // // // // also Candle High and Low must be above than lc Fast & lc Slow ... // && longEntryPrice > xmaState.lcFast // && longEntryPrice > xmaState.lcSlow // && ( // !IsSharpBullishHappens( // bar_index, // marketLen * 2 // ) // || IsSharpBearishHappens( // bar_index, // marketLen * 2 // ) // ) // ; // // Check for Long Trades if some Sharp Bullish Happens, // Decrease sl size for fixing tps ... // if (isSharpBullishHappens) { // sl = sl / 1.5; // } // // TODO: Remove this ... // if (xmaStates[0].marketMiddleage > xmaStates[1].marketMiddleage) { // r2rRatio = r2rRatio * 2; // } // hasLongSignal = // // Global ... true // && ( // // XMA ... ( // true // // Check Medium Cycle is in TrendDown ... && xmaStates[0].mcSlow > xmaStates[0].mcFast && xmaStates[1].mcSlow > xmaStates[1].mcFast && xmaStates[2].mcSlow > xmaStates[2].mcFast // // Check Market Middleage Cross Over MC Slow ... // && isMarketMiddleCrossOverMCSlow // && xmaStates[0].marketMiddleage >= (5 * _Point); && xmaStates[0].marketMiddleage > xmaStates[0].mcSlow && !(xmaStates[1].marketMiddleage >= xmaStates[1].mcSlow) // // IMPORTANT: by passing this condition i can Increase r2r ration ... // && xmaStates[0].marketMiddleage > xmaStates[1].marketMiddleage && MathAbs(xmaStates[0].marketMiddleage - xmaStates[1].marketMiddleage) > _Point ) // || // // OSC ... // ( // // // true // // // // Check osc fast cross over slow ... // && oscStates[1].fastOSC > oscStates[1].slowOSC // && !(oscStates[2].fastOSC >= oscStates[2].slowOSC) // // // // Check OSC Fast bigger than 0.5 ... // && oscStates[1].fastOSC > 0.5 // && ( // xmaStates[1].mcFast > xmaStates[1].mcSlow // ? // // // xmaStates[1].marketMiddleage > xmaStates[1].mcSlow // // // && xmaStates[1].marketMiddleage > xmaStates[2].marketMiddleage // && xmaStates[1].marketMiddleage > xmaStates[3].marketMiddleage // && xmaStates[2].marketMiddleage > xmaStates[3].marketMiddleage // : // true // ) // ) ) ; ``` ```mql4 // // TODO: Determines Where and How close Long Trades on Trend Reversal Points ... closeLongTrades = false // // This is One Conditions ... // ( // // // xmaStates[0].marketMiddleage < xmaStates[0].mcFast // && ( // xmaStates[0].marketMiddleage < xmaStates[0].mcSlow // || xmaStates[1].marketMiddleage < xmaStates[1].mcSlow // || xmaStates[2].marketMiddleage < xmaStates[2].mcSlow // ) // // // && xmaStates[0].mcFast > xmaStates[0].mcSlow // // // && xmaStates[0].marketMiddleage < xmaStates[1].marketMiddleage // && xmaStates[1].marketMiddleage < xmaStates[2].marketMiddleage // ) ; // waitForLongSignals = true; // waitForLongSignals // ? // // // true // // // // Closing Options ... // // // // Trades Doesnt Closed ... // && !closeLongTrades // // // // PRICE ... // // // // Bullish Sharp doesnt occured ... // && !isSharpBullishHappens // // // // XMA ... // // // && xmaStates[0].marketMiddleage < xmaStates[0].mcFast // && !( // // // // On MC Trend Up ... // xmaStates[0].mcFast > xmaStates[0].mcSlow // ? // // // // Market Middleage doesnt Trending Down ... // xmaStates[0].marketMiddleage - xmaStates[0].mcFast > xmaStates[1].marketMiddleage - xmaStates[1].mcFast // && xmaStates[0].marketMiddleage - xmaStates[0].mcFast > xmaStates[2].marketMiddleage - xmaStates[2].mcFast // && xmaStates[0].marketMiddleage - xmaStates[0].mcFast > xmaStates[3].marketMiddleage - xmaStates[3].mcFast // && xmaStates[1].marketMiddleage - xmaStates[1].mcFast > xmaStates[3].marketMiddleage - xmaStates[3].mcFast // : // true // ) // : // // // true // && ( // // // // PRICE ... // // isSharpBearishHappens // // // // XMA ... // isMCFastCrossUnderSlow // || isMarketMiddleCrossUnderMCSlow // ) ; ``` ```mql4 // bool xmaHasLongSignal = // // Global ... true // // XMA ... // // Check Medium Cycle is in TrendDown ... // && xmaStates[0].mcSlow > xmaStates[0].mcFast // && xmaStates[1].mcSlow > xmaStates[1].mcFast // && xmaStates[2].mcSlow > xmaStates[2].mcFast // // Check Market Middleage Cross Over MC Slow ... && isMarketMiddleageTrendUp // // Check distance between Medium Cycle Market && isMarketMiddleCrossOverMCSlow // && xmaStates[0].marketMiddleage > xmaStates[0].mcSlow // && MathAbs(xmaStates[1].marketMiddleage - xmaStates[2].mcSlow) > _Point // // IMPORTANT: by passing this condition i can Increase r2r ration ... // && xmaStates[0].marketMiddleage > xmaStates[1].marketMiddleage && MathAbs(xmaStates[1].marketMiddleage - xmaStates[2].marketMiddleage) > _Point // // OSC ... && oscStates[1].fastOSC > 0.5 && !isOSCPowerTrendDown && oscStates[1].powerOSC > 0 // // PRICE ... && !isSharpBullishHappens && longEntryPrice < marketHigh[0] && marketHigh[0] > marketHigh[1] && marketHigh[0] > marketHigh[2] ; // bool oscHasLongSignal = // false // // OSC ... // // Check osc is Trending Up ... // isOSCTrendUp // // Check osc fast cross over slow ... // isOSCFastCrossOverSlow // // Check OSC Market not Ranging ... // && !isOSCMarketRanging // // Check OSC Fast bigger than 0.5 ... // && oscStates[1].fastOSC > 0.5 // && oscStates[1].slowOSC > 0.5 // // PRICE ... // && !isSharpBullishHappens // && longEntryPrice < marketHigh[0] // && marketHigh[0] > marketHigh[1] // && marketHigh[0] > marketHigh[2] ; // bool hasLongSignal = xmaHasLongSignal || oscHasLongSignal ; ``` ```mql4 // bool hasLongSignal = // // Global ... true // && // XMA ... // // Check Parabolic Sar Cross Under Market Middleage // Or Trending Down ... isParabolicCrossUnderMarketMiddle && // // Check PSar Value is Bigger Than Market Middleage ... xmaStates[1].parabolicSAR < xmaStates[1].marketMiddleage && // // Check Parabolic Revrse Change bigger than Prev Cancle Close ... xmaStates[1].parabolicSAR < MathMin(marketOpen[1], marketClose[1]) && // // Now We Have Separate our Conditions based on // Market Trends ... // // Medium Cycle Market Trends Up ... isMCTrendUp ? ( // // Market Middle must be in Trending Up ... isMarketMiddleageTrendUp && // // Market Middle Must be less than Maximum in Cycle ... xmaStates[1].marketMiddleage < marketMiddlesMinMax.max && // // Market Middleage must be above of MC Fast ... xmaStates[1].marketMiddleage > xmaStates[1].mcFast && // // Check Distance between SC Fast and Market Middle ... MathAbs(xmaStates[1].scFast - xmaStates[1].scSlow) > (3 * _Point) // // Minimum Signal Power of OSC ... // MathAbs(oscStates[1].powerOSC > minPowOSC) ) : // // Medium Cycle Market Trends Down ... false // () ; ``` ```mql4 // // Based On MC Market Trend Up ... // // Based On MC Market Down Trend ... // isMCTrendDown // || isMCFastCrossUnderSlow // ? // ( // // Find SC Fast Cross Over SC Slow, which happens betweentwo of SC Fast Under SC Slow ... // isSCFastCrossOverSlow // // // // Find the Moment which Market Middleage Cross Over MC Fast ... // isMarketMiddleCrossOverMCFast // // // // Check Parabolix SAR for Long Trades ... // && xmaStates[0].parabolicSAR < xmaStates[0].marketMiddleage // && xmaStates[1].parabolicSAR < xmaStates[1].marketMiddleage // // // // Check Market Middle and Parabolic SAR Distance ... // && MathAbs(xmaStates[1].marketMiddleage - xmaStates[1].parabolicSAR) >= 1 // // // // Check Distance between MCSlow and MCFast bigger than MarketMiddle and Parabolic SAR ... // && MathAbs(xmaStates[1].mcFast - xmaStates[1].mcSlow) > MathAbs(xmaStates[1].marketMiddleage - xmaStates[1].parabolicSAR) // ) // : // // // // Based On MC Market Up Trend ... // false ``` ```mql4 // oscHasLongSignal = // oscStates[0].fastOSC > oscStates[0].slowOSC && ( ( oscStates[0].fastOSC > 0.5 && oscStates[0].fastOSC < 0.75 ) || oscStates[0].fastOSC <= 0.5 ) && ( oscStates[0].powerOSC > 0 || oscStates[1].powerOSC > 0 ) // && xmaStates[0].scFast > xmaStates[0].marketMiddleage && MathAbs(xmaStates[0].scFast - xmaStates[0].marketMiddleage) > (20 * _Point) // && xmaStates[1].scFast > xmaStates[1].marketMiddleage && MathAbs(xmaStates[1].scFast - xmaStates[1].marketMiddleage) > (20 * _Point) // && xmaStates[2].scFast > xmaStates[2].marketMiddleage // && xmaStates[0].mcFast > xmaStates[0].mcSlow && MathAbs(xmaStates[0].mcFast - xmaStates[0].mcSlow) > (50 * _Point) // && xmaStates[0].mcFast < xmaStates[0].scFast && xmaStates[0].mcFast < xmaStates[0].parabolicSAR // && xmaStates[0].parabolicSAR < xmaStates[0].marketMiddleage && xmaStates[1].parabolicSAR < xmaStates[1].marketMiddleage // && !isSharpBullishHappens // && longEntryPrice > xmktStates[0].highestLow && longEntryPrice > xmaStates[0].marketMiddleage // && xmktStates[0].highestLow > xmaStates[0].scFast && xmktStates[0].lowestHigh < xmaStates[0].scFast && xmktStates[0].lowestHigh < xmaStates[0].marketMiddleage ; ``` ```mql4 ``` ```mql4 ``` ```mql4 ``` ```mql4 ``` ```mql4 ``` ```mql4 ``` ```mql4 ``` ```mql4 ``` ```mql4 ``` ```mql4 ``` ```mql4 ```