Mohamed Abdelmaaboud / Profilo
- Informazioni
7+ anni
esperienza
|
2
prodotti
|
0
versioni demo
|
3
lavori
|
0
segnali
|
0
iscritti
|
✅ CFTe (Certified Financial Technician) holder from IFTA (International Federation of Technical Analysts).
✅ CETA (Certified ESTA Technical Analyst) holder from ESTA (The Egyptian Society of Technical Analysts).
✅ The founder of Trades Coding for trading software products and services.
👉 Check out the website through the link: https://tradescoding.com/
✅ The founder of Trades Analysis for trading training and consulting services.
👉 Check out the website through the link: https://tradesanalysis.com/
✅ I am passionate about what I do and interested in adding more value using my experience in the field.
✅ I am the author of many articles here on the MQL5 website about algorithmic trading and how to create a trading system based on the most popular technical indicators.
You can find them through the following link:
👉 https://www.mql5.com/en/users/m.aboud/publications
✅You can join my telegram channel through the following link:
👉 https://t.me/tradescoding
✅ I author trading tools for MetaTrader 4 and MetaTrader 5.
You can find them through the following link:
👉 https://www.mql5.com/en/users/m.aboud/seller
✅ I can code smoothly with programming languages MQL4, and MQL5 to create trading systems for MetaTrader 4 and MetaTrader 5.
If you want a personal job, you can request that through the following link:
👉 https://www.mql5.com/en/job/new?prefered=m.aboud
Un nuovo articolo della nostra serie sull'imparare a progettare un sistema di trading con gli indicatori tecnici più popolari tramite MQL5 per poterli utilizzare in MetaTrader 5. In questo articolo impareremo come progettare un sistema di trading tramite l'indicatore Williams %R.
Ecco un nuovo articolo della nostra serie su come progettare un sistema di trading con gli indicatori più comuni, parleremo in dettaglio dell'indicatore Ichimoku e di come progettare un sistema di trading con questo indicatore.
Ecco un nuovo articolo della nostra serie sull'apprendimento di come progettare sistemi di trading basati sugli indicatori tecnici più comuni. Questo articolo sarà dedicato all'indicatore Volumes. Il volume come concetto è uno dei fattori più importanti nel trading sui mercati finanziari e dobbiamo prestargli attenzione. Attraverso questo articolo, impareremo come progettare un semplice sistema di trading tramite l'indicatore Volumes.
Il nuovo articolo della nostra serie sulla progettazione di un sistema di trading basato sugli indicatori tecnici più popolari considera un nuovo indicatore tecnico - il Money Flow Index (MFI). Lo impareremo in dettaglio e svilupperemo un semplice sistema di trading tramite MQL5 per eseguirlo in MetaTrader 5.
Benvenuti nel nuovo articolo della nostra serie sull'apprendimento di come progettare sistemi di trading basati sugli indicatori tecnici più popolari. In questo articolo, impareremo a conoscere un nuovo indicatore tecnico chiamato Indicatore di Accumulazione/Distribuzione e scopriremo come progettare un sistema di trading MQL5 basato su semplici strategie con AD.
//| TRENDLINE_RVI_DeMarker_ADX_ACMA_AO SYSTEM.mq5 |
//| Copyright 2022, MetaQuotes Ltd. |
//| https://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "Copyright 2022, MetaQuotes Ltd."
#property link "https://www.mql5.com"
#property version "1.00"
//+------------------------------------------------------------------+
//| Expert initialization function |
//+------------------------------------------------------------------+
int OnInit() {
//--- create timer EventSetTimer(60); //--- return(INIT_SUCCEEDED); }
//+------------------------------------------------------------------+
//| Expert deinitialization function |
//+------------------------------------------------------------------+
void OnDeinit(const int reason) {
//--- destroy timer EventKillTimer(); }
//+------------------------------------------------------------------+
//| Expert tick function |
//+------------------------------------------------------------------+
void OnTick() {
////////////////////////Trend Lines//////////////////////////////////// long candlesUp = ChartGetInteger(0, CHART_FIRST_VISIBLE_BAR, 0); double pLow[]; ArraySetAsSeries(pLow, true); CopyLow(_Symbol, _Period, 0, candlesUp, pLow); long candleLow = ArrayMinimum(pLow, 0, candlesUp); MqlRates pArrayUp[]; ArraySetAsSeries(pArrayUp, true); long DataUp = CopyRates(_Symbol, _Period, 0, candlesUp, pArrayUp); ObjectDelete(_Symbol,"UpwardTrendline"); ObjectCreate(_Symbol, "UpwardTrendline", OBJ_TREND, 0, pArrayUp[candleLow].time, pArrayUp[candleLow].low, pArrayUp[0].time, pArrayUp[0].low); ObjectSetInteger(0, "UpwardTrendline", OBJPROP_COLOR, Blue); ObjectSetInteger(0, "UpwardTrendline", OBJPROP_STYLE, STYLE_SOLID); ObjectSetInteger(0, "UpwardTrendline", OBJPROP_WIDTH, 1); ObjectSetInteger(0, "UpwardTrendline", OBJPROP_RAY_RIGHT, true); long candlesDown = ChartGetInteger(0, CHART_FIRST_VISIBLE_BAR, 0); double pHighDown[]; ArraySetAsSeries(pHighDown, true); CopyHigh(_Symbol, _Period, 0, candlesDown, pHighDown); long candleHighDown = ArrayMaximum(pHighDown, 0, candlesDown); MqlRates pArrayDown[]; ArraySetAsSeries(pArrayDown, true); int DataDown = CopyRates(_Symbol, _Period, 0, candlesDown, pArrayDown); ObjectDelete(_Symbol, "DownwardTrendline"); ObjectCreate(_Symbol, "DownwardTrendline", OBJ_TREND, 0, pArrayDown[candleHighDown].time, pArrayDown[candleHighDown].high, pArrayDown[0].time, pArrayDown[0].high); ObjectSetInteger(0, "DownwardTrendline", OBJPROP_COLOR, Blue); ObjectSetInteger(0, "DownwardTrendline", OBJPROP_STYLE, STYLE_SOLID); ObjectSetInteger(0, "DownwardTrendline", OBJPROP_WIDTH, 1); ObjectSetInteger(0, "DownwardTrendline", OBJPROP_RAY_RIGHT, true); long candlesSupport = ChartGetInteger(0, CHART_FIRST_VISIBLE_BAR, 0); double pLowSupport[]; ArraySetAsSeries(pLowSupport, true); CopyLow(_Symbol, _Period, 0, candlesSupport, pLowSupport); long candleLowSupport = ArrayMinimum(pLowSupport, 0, candlesSupport); MqlRates pArraySupport[]; ArraySetAsSeries(pArraySupport, true); int DataSupport = CopyRates(_Symbol, _Period, 0, candlesSupport, pArraySupport); ObjectDelete(_Symbol, "supportLine"); ObjectCreate(_Symbol, "supportLine", OBJ_HLINE, 0, pArraySupport[candleLowSupport].time, pArraySupport[candleLowSupport].low, pArraySupport[0].time, pArraySupport[0].low); ObjectSetInteger(0, "supportLine", OBJPROP_COLOR, Green); ObjectSetInteger(0, "supportLine", OBJPROP_STYLE, STYLE_SOLID); ObjectSetInteger(0, "supportLine", OBJPROP_WIDTH, 3); ObjectSetInteger(0, "supportLine", OBJPROP_RAY, true); long candlesResistance = ChartGetInteger(0, CHART_FIRST_VISIBLE_BAR, 0); double pHighResistance[]; ArraySetAsSeries(pHighResistance, true); CopyHigh(_Symbol, _Period, 0, candlesResistance, pHighResistance); long candleHighResistance = ArrayMaximum(pHighResistance, 0, candlesResistance); MqlRates pArrayResistance[]; ArraySetAsSeries(pArrayResistance, true); long DataResistance = CopyRates(_Symbol, _Period, 0, candlesResistance, pArrayResistance); ObjectDelete(_Symbol, "resistanceLine"); ObjectCreate(_Symbol, "resistanceLine", OBJ_HLINE, 0, pArrayResistance[candleHighResistance].time, pArrayResistance[candleHighResistance].high, pArrayResistance[0].time, pArrayResistance[0].high); ObjectSetInteger(0, "resistanceLine", OBJPROP_COLOR, Red); ObjectSetInteger(0, "resistanceLine", OBJPROP_STYLE, STYLE_SOLID); ObjectSetInteger(0, "resistanceLine", OBJPROP_WIDTH, 3); ObjectSetInteger(0, "resistanceLine", OBJPROP_RAY_RIGHT, true); /////////////////////////////////////VIDYA///////////////////////////////////////////// MqlRates priceArrayVIDYA[]; double vidyaArray[]; double vidyaArray1[]; int DataVIDYA = CopyRates(_Symbol, _Period, 0, 3, priceArrayVIDYA); ArraySetAsSeries(vidyaArray, true); ArraySetAsSeries(vidyaArray1, true); int vidyaDef = iVIDyA(_Symbol, _Period, 9, 12, 0, PRICE_CLOSE); int vidyaDef1 = iVIDyA(_Symbol, _Period, 20, 50, 0, PRICE_CLOSE); CopyBuffer(vidyaDef, 0, 0, 3, vidyaArray); CopyBuffer(vidyaDef1, 0, 0, 3, vidyaArray1); double currentCloseVIDYA = NormalizeDouble(priceArrayVIDYA[2].close, 6); double vidyaVal = NormalizeDouble(vidyaArray[0], 6); double vidyaVal1 = NormalizeDouble(vidyaArray1[0], 6); ///////////////////RVI Moving Average///////////////////////////////////////////////// MqlRates pArrayRVI_MA[]; double maArrayRVI_MA[]; double rviArray[]; double rviSignalArray[]; int DataRVI_MA = CopyRates(_Symbol, _Period, 0, 1, pArrayRVI_MA); ArraySetAsSeries(maArrayRVI_MA, true); ArraySetAsSeries(rviArray, true); ArraySetAsSeries(rviSignalArray, true); int rviDef = iRVI(_Symbol, _Period, 10); int maDefRVI_MA = iMA(_Symbol, _Period, 100, 0, MODE_EMA, PRICE_CLOSE); CopyBuffer(rviDef, 0, 0, 3, rviArray); CopyBuffer(rviDef, 1, 0, 3, rviSignalArray); CopyBuffer(maDefRVI_MA, 0, 0, 3, maArrayRVI_MA); double rviValue = NormalizeDouble(rviArray[0], 3); double rviSignalValue = NormalizeDouble(rviSignalArray[0], 3); double maValueRVI_MA = NormalizeDouble(maArrayRVI_MA[0], 3); ////////////////////ACELERATOR_OSCILLATOR////////////////////////////////////// MqlRates pArrayACMA[]; double acArray[]; double maArrayACMA[]; int DataACMA = CopyRates(_Symbol,_Period, 0, 1, pArrayACMA); ArraySetAsSeries(acArray, true); ArraySetAsSeries(maArrayACMA, true); int acDefACMA = iAC(_Symbol, _Period); int maDefACMA = iMA(_Symbol, _Period, 50, 0, MODE_EMA, PRICE_CLOSE); CopyBuffer(acDefACMA, 0, 0, 3, acArray); CopyBuffer(maDefACMA,0, 0, 3, maArrayACMA); int acMaxArray = ArrayMaximum(acArray, 1, WHOLE_ARRAY); int acMinArray = ArrayMinimum(acArray, 1, WHOLE_ARRAY); double closingPriceACMA = pArrayACMA[0].close; double acValue = NormalizeDouble(acArray[0], 7); double acMaxValue = NormalizeDouble(acArray[acMaxArray], 7); double acMinValue = NormalizeDouble(acArray[acMinArray], 7); double maValueACMA = NormalizeDouble(maArrayACMA[0], 7);
///////////////////////AWESOME_OSCILLATOR/////////////////////////////////////////// MqlRates pArrayAO[]; double aoArray[]; double maArrayAO[]; int DataAO = CopyRates(_Symbol, _Period, 0, 1, pArrayAO); ArraySetAsSeries(aoArray, true); ArraySetAsSeries(maArrayAO, true); int aoDef = iAO(_Symbol, _Period); int maDefAO = iMA(_Symbol, _Period, 50, 0, MODE_EMA, PRICE_CLOSE); CopyBuffer(aoDef, 0, 0, 3, aoArray); CopyBuffer(maDefAO, 0, 0,3, maArrayAO); double closingPriceAO = pArrayAO[0].close; double aoValue = NormalizeDouble(aoArray[0], 7); double maValueAO = NormalizeDouble(maArrayAO[0], 7); ///////////////////////////DeMARKER_DIVERGENCE////////////////////////////////////////// double deMarkerArray[]; MqlRates pArrayDeMarker[]; ArraySetAsSeries(deMarkerArray, true); ArraySetAsSeries(pArrayDeMarker, true); int deMarkerDef = iDeMarker(_Symbol, _Period, 14); int pDataDeMarker = CopyRates(_Symbol, _Period, 0, 14, pArrayDeMarker); CopyBuffer(deMarkerDef, 0, 0, 14, deMarkerArray); double deMarkerVal = NormalizeDouble(deMarkerArray[0], 4); double deMarkerPrevVal = NormalizeDouble(deMarkerArray[1], 4); double currentHighDeMarker = NormalizeDouble(pArrayDeMarker[0].high, 6); double currentLowDeMarker = NormalizeDouble(pArrayDeMarker[0].low, 6); double prevHighDeMarker = NormalizeDouble(pArrayDeMarker[1].high, 6); double prevLowDeMarker = NormalizeDouble(pArrayDeMarker[1].low, 6); /////////////////////////////////////ADX//////////////////////////////////////
//creating a variable for signal //Create arrays for current ADX value, previous ADX value, +DI value and -DI value double ADXArray0[]; double ADXArray1[]; double PDIArray[]; double NDIArray[]; //Identifying the ADX, positive DI, negative DI. int ADXDef = iADX(_Symbol, _Period, 14); //Sort price arrays from current data ArraySetAsSeries(ADXArray0,true); ArraySetAsSeries(ADXArray1,true); ArraySetAsSeries(PDIArray,true); ArraySetAsSeries(NDIArray,true); //Filling data according to created ADX CopyBuffer(ADXDef,0,0,3,ADXArray0); CopyBuffer(ADXDef,0,0,2,ADXArray1); CopyBuffer(ADXDef,1,0,3,PDIArray); CopyBuffer(ADXDef,2,0,3,NDIArray); //Getting values of the current data double ADXValue=NormalizeDouble(ADXArray0[0], 2); double ADXValueLast=NormalizeDouble(ADXArray1[1], 2); double PDIValue=NormalizeDouble(PDIArray[0], 2); double NDIValue=NormalizeDouble(NDIArray[0], 2); //////////////////////////CONDITIONS//////////////////////////////////////////// bool BUY_CONDITION_1 = (vidyaVal > vidyaVal1); bool BUY_CONDITION_2 = (acValue > acMaxValue) && (closingPriceACMA > maValueACMA); bool BUY_CONDITION_3 = (aoValue > 0) && (closingPriceAO > maValueAO); bool BUY_CONDITION_4 = (pArrayRVI_MA[0].close > maValueRVI_MA) && (rviValue > rviSignalValue); bool BUY_CONDITION_5 = (ADXValue > 25) && (ADXValue > ADXValueLast); bool BUY_CONDITION_6 = (PDIValue > NDIValue); bool BUY_CONDITION_7 = (currentHighDeMarker > prevHighDeMarker) && (deMarkerVal < deMarkerPrevVal); //For BEARISH DIVERGENCE. bool SELL_CONDITION_1 = (vidyaVal < vidyaVal1); bool SELL_CONDITION_2 = (acValue < acMinValue) && (closingPriceACMA < maValueACMA); bool SELL_CONDITION_3 = (aoValue < 0) && (closingPriceAO < maValueAO); bool SELL_CONDITION_4 = (pArrayRVI_MA[0].close < maValueRVI_MA) && (rviValue < rviSignalValue); bool SELL_CONDITION_5 = (ADXValue > 25) && (ADXValue > ADXValueLast); bool SELL_CONDITION_6 = (PDIValue < NDIValue); bool SELL_CONDITION_7 = (currentLowDeMarker < prevLowDeMarker) && (deMarkerVal > deMarkerPrevVal); //For BULLISH DIVERGENCE. if((BUY_CONDITION_1) == 1) { Comment("BUY","\n", "Current Close Value is ",currentCloseVIDYA,"\n", "Current VIDYA (9,12) Value is ",vidyaVal,"\n", "Current VIDYA (20,50) Value is ",vidyaVal1); if((BUY_CONDITION_5 && BUY_CONDITION_6) == 1) { Comment("AC Closing Price Is ", closingPriceACMA, "\n", "AC Value Is ", acValue, "\n", "AC Max Value Is ", acMaxValue, "\n", "AC Min Value Is ", acMinValue, "\n", "AC MA Value Is ", maValueACMA, "\n", "AO Closing Price is ", closingPriceAO, "\n", "AO Value Is ", aoValue, "\n", "AO MA Value Is ", maValueAO, "\n", "RVI Closing price is ", pArrayRVI_MA[0].close, "\n", "RVI MA Value is ", maValueRVI_MA, "\n", "Relative Vigor Index Is ", rviValue, "\n", "RVI Signal Value Is ", rviSignalValue, "\n", "ADX Value is ", ADXValue, "\n", "ADX Value Last is ", ADXValueLast, "\n", "+DI Value is ", PDIValue, "\n", "-DI Value is ", NDIValue, "\n", "Current High Is ", currentHighDeMarker, "\n", "Prev. High Value Is ", prevHighDeMarker, "\n", "Current DeMarker Value Is ", deMarkerVal, "\n", "Prev. DeMarker Value Is ", deMarkerPrevVal); } } if((SELL_CONDITION_1) == 1) { Comment("SELL","\n", "Current Close Value is ",currentCloseVIDYA,"\n", "Current VIDYA (9,12) Value is ",vidyaVal,"\n", "Current VIDYA (20,50) Value is ",vidyaVal1); if((SELL_CONDITION_5 && SELL_CONDITION_6) == 1) { Comment("AC Closing Price Is ", closingPriceACMA, "\n", "AC Value Is ", acValue, "\n", "AC Max Value Is ", acMaxValue, "\n", "AC Min Value Is ", acMinValue, "\n", "AC MA Value is ", maValueACMA, "\n", "AO Closing Price Is ", closingPriceAO, "\n", "AO Value Is ", aoValue, "\n", "AO MA Value Is ", maValueAO, "\n", "RVI Closing Price Is ", pArrayRVI_MA[0].close, "\n", "RVI MA Value Is ", maValueRVI_MA, "\n", "Relative Vigor Index Is ", rviValue, "\n", "RVI Signal Value Is ", rviSignalValue, "\n", "ADX Value is ", ADXValue, "\n", "ADX Value Last is ", ADXValueLast, "\n", "+DI Value is ", PDIValue, "\n", "-DI Value is ", NDIValue, "\n", "Current Low Is ", currentLowDeMarker, "\n", "Prev. Low Is ", prevLowDeMarker, "\n", "Current DeMarker Value Is ", deMarkerVal, "\n", "Prev. DeMarker Value Is ", deMarkerPrevVal); } } } //+------------------------------------------------------------------+
//| Timer function |
//+------------------------------------------------------------------+
void OnTimer() {
//--- }
//+------------------------------------------------------------------+
//| Trade function |
//+------------------------------------------------------------------+
void OnTrade() {
//--- }
//+------------------------------------------------------------------+
//| TradeTransaction function |
//+------------------------------------------------------------------+
void OnTradeTransaction(const MqlTradeTransaction& trans, const MqlTradeRequest& request, const MqlTradeResult& result) {
//--- }
//+------------------------------------------------------------------+
//| Tester function |
//+------------------------------------------------------------------+
double OnTester() {
//--- double ret=0.0;
//--- //--- return(ret); }
//+------------------------------------------------------------------+
//| TesterInit function |
//+------------------------------------------------------------------+
void OnTesterInit() {
//--- }
//+------------------------------------------------------------------+
//| TesterPass function |
//+------------------------------------------------------------------+
void OnTesterPass() {
//--- }
//+------------------------------------------------------------------+
//| TesterDeinit function |
//+------------------------------------------------------------------+
void OnTesterDeinit() {
//--- }
//+------------------------------------------------------------------+
//| ChartEvent function |
//+------------------------------------------------------------------+
void OnChartEvent(const int id, const long &lparam, const double &dparam, const string &sparam) {
//--- }
//+------------------------------------------------------------------+
//| BookEvent function |
//+------------------------------------------------------------------+
void OnBookEvent(const string &symbol) {
//--- }
//+------------------------------------------------------------------+ //+------------------------------------------------------------------+ //+------------------------------------------------------------------+ //+------------------------------------------------------------------+ //+------------------------------------------------------------------+ //+------------------------------------------------------------------+ //+------------------------------------------------------------------+ //+------------------------------------------------------------------+ //+------------------------------------------------------------------+ //+------------------------------------------------------------------+ //+------------------------------------------------------------------+ //+------------------------------------------------------------------+ //+------------------------------------------------------------------+ //+------------------------------------------------------------------+ //+------------------------------------------------------------------+ //+------------------------------------------------------------------+ //+------------------------------------------------------------------+
Questo è un nuovo articolo che continua la nostra serie per principianti su come progettare un sistema di trading basato su alcuni degli indicatori popolari. Scopriremo un nuovo indicatore che è On Balance Volume (OBV) e impareremo come usarlo e a progettare un sistema di trading basato su di esso.
In questo articolo continueremo la nostra serie su come progettare un sistema di trading utilizzando gli indicatori più popolari. Impareremo a conoscere nel dettaglio l'indicatore Parabolic SAR e come progettare un sistema di trading da utilizzare in MetaTrader 5 utilizzando alcune semplici strategie.
In questo articolo, impareremo un nuovo strumento tecnico che può essere utilizzato nel trading, come continuazione all'interno della serie in cui impariamo a progettare semplici sistemi di trading. Questa volta lavoreremo con un altro indicatore tecnico popolare: Average True Range (ATR).
In questo articolo, continueremo la nostra serie sulla progettazione di un sistema di trading utilizzando gli indicatori più popolari e parleremo dell'indicatore average directional index (ADX). Scopriremo questo indicatore nel dettaglio per capirlo bene e impareremo come usarlo attraverso una semplice strategia. Imparando qualcosa approfonditamente possiamo ottenere più intuizioni e possiamo usarlo meglio.
In questo articolo, continuiamo la nostra serie di apprendimento: questa volta impareremo come progettare un sistema di trading utilizzando uno degli indicatori più popolari e utili, che è l'indicatore Oscillatore Stocastico, per aggiungere un nuovo mattone alla nostra conoscenza delle basi.
In questo articolo, impareremo un nuovo strumento dalla nostra serie: impareremo come progettare un sistema di trading basato su uno degli indicatori tecnici più popolari Moving Average Convergence Divergence (MACD).
In questo nuovo articolo della nostra serie dedicata a come progettare sistemi di trading, presenterò il Commodities Channel Index (CCI), spiegherò le sue caratteristiche e condividerò con voi come creare un sistema di trading basato su questo indicatore.
Nel mio precedente articolo ho parlato dell'importanza di identificare la tendenza di mercato, ovvero la direzione dei prezzi. In questo articolo esaminerò uno dei indicatori tecnici più importanti: l'indicatore Momentum. Vedremo insieme come progettare un sistema di trading basato sul Momentum.
In questo articolo, vi parlerò di uno degli indicatori più popolari e utilizzati nel mondo del trading, ovvero l’RSI. Vedremo insieme come mettere in piedi un sistema di trading con questo indicatore.
In questo articolo, parleremo di uno dei metodi per fare trading utilizzando le bande. Questa volta prenderemo in considerazione le Envelopes. Vi mostrerò quanto è facile creare alcune strategie basate su questo indicatore.
In questo articolo impareremo a conoscere le bande di Bollinger, uno degli indicatori più popolari nel mondo del trading. Prenderemo in considerazione l'analisi tecnica e vedremo come progettare un sistema di trading algoritmico basato sull'indicatore Bollinger Bands.
Esistono molte strategie che possono essere utilizzate per filtrare i segnali generati in base a qualsiasi strategia, anche utilizzando la stessa media mobile oggetto di questo articolo. Quindi, l'obiettivo di questo articolo è condividere con te alcune delle strategie di media mobile e come progettare un sistema di trading algoritmico.
Questo articolo mostra le basi di MQL per i principianti che vogliono progettare il loro sistema di trading algoritmico (Expert Advisor) attraverso la progettazione di un semplice sistema di trading algoritmico, dopo aver passato in rassegna alcune delle basi di MQL5