questo indicatore mt4 non ha errori, eppure non disegna lo stocastico nel grafico…
- User
questo indicatore mt4 non ha errori, eppure non disegna lo stocastico nel grafico separato e neppure le frecce sul grafico principale. sai dirmi perchè? //+------------------------------------------------------------------+ //| MTF Stochastic.mq4 | //| 2007, Christof Risch (iya) | //| Stochastic indicator from any timeframe. | //+------------------------------------------------------------------+ // Change Log: // 2.1 2012 07 24 Modified to display only the Signal line (smoothed sma) // cr: 2012 07 20 Added NextHigherAuto to automatically seletc the next higher time frame // Added HidePctD to suppress the Slow line, prn
#property link "http://www.forexfactory.com/showthread.php?t=30109" #property indicator_separate_window #property indicator_buffers 6 #property indicator_color1 Green //C'255,255,255' // White // %K line #property indicator_color2 Red //Yellow // DimGray // %D line #property indicator_color3 Green // C'255,255,255' // White // %K line of the current candle #property indicator_color4 Red //Yellow // DimGray // %D line of the current candle #property indicator_level1 80 #property indicator_level2 20 #property indicator_level3 50 #property indicator_levelcolor DarkSlateGray #property indicator_maximum 100 #property indicator_minimum 0
//---- input parameters extern bool NextHigherAuto = true; extern bool HidePctK = false; extern bool HidePctD = false; extern int TimeFrame = 0, // {1=M1, 5=M5, 15=M15, ..., 1440=D1, 10080=W1, 43200=MN1} KPeriod = 11, DPeriod = 3, Slowing = 3, MAMethod = 0, // {0=SMA, 1=EMA, 2=SMMA, 3=LWMA} PriceField = 0; // {0=Hi/Low, 1=Close/Close} extern bool ShowClock = false; // display time to candle close countdown extern color ClockColor = Red;
//---- indicator buffers double BufferK[], BufferD[], BufferK_Curr[], BufferD_Curr[];
double ArrowUpBuffer[]; double ArrowDownBuffer[]; //---- string IndicatorName = "", TimeLabelName = "";
//+------------------------------------------------------------------+ //| Custom indicator initialization function | //+------------------------------------------------------------------+ int init() { if ( TimeFrame == 0 ) TimeFrame = Period(); if ( NextHigherAuto ) TimeFrame = GetHigherTimeFrame( TimeFrame ) ; //---- name for DataWindow and indicator subwindow label switch(TimeFrame) { case 1: IndicatorName="Period M1"; break; case 5: IndicatorName="Period M5"; break; case 15: IndicatorName="Period M15"; break; case 30: IndicatorName="Period M30"; break; case 60: IndicatorName="Period H1"; break; case 240: IndicatorName="Period H4"; break; case 1440: IndicatorName="Period D1"; break; case 10080: IndicatorName="Period W1"; break; case 43200: IndicatorName="Period MN1"; break; default: {TimeFrame = Period(); init(); return(0);} }
IndicatorName = IndicatorName+" Stoch("+KPeriod+","+DPeriod+","+Slowing+")"; IndicatorShortName(IndicatorName); IndicatorDigits(1);string TimeFrameStr = TF2Str(TimeFrame);
//---- indicator lines SetIndexBuffer(0,BufferK); SetIndexBuffer(1,BufferD); SetIndexBuffer(2,BufferK_Curr); SetIndexBuffer(3,BufferD_Curr); SetIndexStyle(0,DRAW_LINE,EMPTY,1); //SetIndexStyle(0,DRAW_NONE); SetIndexStyle(2,DRAW_LINE,EMPTY,1); //SetIndexStyle(2,DRAW_NONE); if ( ! HidePctK ) { SetIndexStyle(0,DRAW_LINE,EMPTY,1); SetIndexStyle(2,DRAW_LINE,EMPTY,1); SetIndexLabel(0,TimeFrameStr+" %K line"); SetIndexLabel(2,TimeFrameStr+" %K CurrBar"); } else { SetIndexStyle(0,DRAW_NONE); SetIndexStyle(2,DRAW_NONE); SetIndexLabel(0,NULL); SetIndexLabel(2,NULL); }
if ( ! HidePctD ) { SetIndexStyle(1,DRAW_LINE,EMPTY,1); SetIndexStyle(3,DRAW_LINE,EMPTY,1); SetIndexLabel(1,TimeFrameStr+" %D Signal"); SetIndexLabel(3,TimeFrameStr+" %D CurrBar"); } else { SetIndexStyle(1,DRAW_NONE); SetIndexStyle(3,DRAW_NONE); SetIndexLabel(1,NULL); SetIndexLabel(3,NULL); } // Aggiunta dei nuovi buffer per le frecce SetIndexBuffer(4, ArrowUpBuffer); SetIndexArrow(4, SYMBOL_ARROWUP); // Parametro per l’icona freccia verso l’alto (puoi usare l’icona che preferisci) SetIndexStyle(4, DRAW_ARROW); SetIndexLabel(4, "Stochastic Arrow Up"); ArraySetAsSeries(ArrowUpBuffer, true);
SetIndexBuffer(5, ArrowDownBuffer); SetIndexArrow(5, SYMBOL_ARROWDOWN); // Parametro per l’icona freccia verso il basso SetIndexStyle(5, DRAW_ARROW); SetIndexLabel(5, "Stochastic Arrow Down"); ArraySetAsSeries(ArrowDownBuffer, true);
} //+------------------------------------------------------------------+ int deinit() { if(TimeLabelName!="") if(ObjectFind (TimeLabelName) != -1) ObjectDelete(TimeLabelName); }
//+------------------------------------------------------------------+ //| MTF Stochastic | //+------------------------------------------------------------------+ int start() { //---- // counted bars from indicator time frame static int countedBars1 = 0;
//---- // counted bars from display time frame if(Bars-1-IndicatorCounted() > 1 && countedBars1!=0) countedBars1 = 0;
int bars1 = iBars(NULL,TimeFrame), start1 = bars1-1-countedBars1, limit1 = iBarShift(NULL,TimeFrame,Time[Bars-1]); if(countedBars1 != bars1-1) { countedBars1 = bars1-1; ArrayInitialize(BufferK_Curr,EMPTY_VALUE); ArrayInitialize(BufferD_Curr,EMPTY_VALUE); if(TimeLabelName!="") if(ObjectFind (TimeLabelName) != -1) ObjectDelete(TimeLabelName); } if(start1 > limit1 && limit1 != -1) start1 = limit1;ArrayInitialize(ArrowUpBuffer, EMPTY_VALUE); ArrayInitialize(ArrowDownBuffer, EMPTY_VALUE); //---- // 3... 2... 1... GO! for(int i = start1; i >= 0; i--) { int shift1 = i;
if(TimeFrame < Period()) shift1 = iBarShift(NULL,TimeFrame,Time[i]); int time1 = iTime (NULL,TimeFrame,shift1), shift2 = iBarShift(NULL,0,time1); double stochK = iStochastic(NULL,TimeFrame,KPeriod,DPeriod,Slowing,MAMethod,PriceField,0,shift1), stochD = iStochastic(NULL,TimeFrame,KPeriod,DPeriod,Slowing,MAMethod,PriceField,1,shift1); //---- // old (closed) candles if(shift1>=1) { BufferK[shift2] = stochK; BufferD[shift2] = stochD; } //---- // current candle if((TimeFrame >=Period() && shift1<=1) || (TimeFrame < Period() &&(shift1==0||shift2==1))) { BufferK_Curr[shift2] = stochK; BufferD_Curr[shift2] = stochD; } //---- // linear interpolatior for the number of intermediate bars, between two higher timeframe candles. int n = 1; if(TimeFrame > Period()) { int shift2prev = iBarShift(NULL,0,iTime(NULL,TimeFrame,shift1+1)); if(shift2prev!=-1 && shift2prev!=shift2) n = shift2prev - shift2; } //---- // apply interpolation double factor = 1.0 / n; if(shift1>=1) if(BufferK[shift2+n]!=EMPTY_VALUE && BufferK[shift2]!=EMPTY_VALUE) { for(int k = 1; k < n; k++) { BufferK[shift2+k] = k*factor*BufferK[shift2+n] + (1.0-k*factor)*BufferK[shift2]; BufferD[shift2+k] = k*factor*BufferD[shift2+n] + (1.0-k*factor)*BufferD[shift2]; } } //---- // current candle if(shift1==0) if(BufferK_Curr[shift2+n]!=EMPTY_VALUE && BufferK_Curr[shift2]!=EMPTY_VALUE) { for(k = 1; k < n; k++) { BufferK_Curr[shift2+k] = k*factor*BufferK_Curr[shift2+n] + (1.0-k*factor)*BufferK_Curr[shift2]; BufferD_Curr[shift2+k] = k*factor*BufferD_Curr[shift2+n] + (1.0-k*factor)*BufferD_Curr[shift2]; } //---- // candle time countdown if(ShowClock) { int m,s; s = iTime(NULL,TimeFrame,0)+TimeFrame*60 - TimeCurrent(); m = (s-s%60)/60; s = s%60; string text; if(s<10) text = "0"+s; else text = ""+s; text = " "+m+":"+text; int window = WindowFind(IndicatorName); if(window==-1) window = WindowOnDropped() ; TimeLabelName = IndicatorName+" Time Counter "+window; if(ObjectFind (TimeLabelName) == -1) ObjectCreate(TimeLabelName, OBJ_TEXT, window, Time[shift2], BufferK_Curr[shift2]+3); else ObjectMove (TimeLabelName, 0, Time[shift2], BufferK_Curr[shift2]+3); ObjectSetText (TimeLabelName, text, 8, "Verdana", ClockColor); } } }// Rileva gli incroci e disegna le frecce for(int j = Bars - countedBars1 - 1; j >= 0; j--) { if(j == 0) continue; // Saltare la barra corrente
double currentK = BufferK_Curr[j]; double currentD = BufferD_Curr[j]; double previousK = BufferK_Curr[j + 1]; double previousD = BufferD_Curr[j + 1]; // Incrocio dal basso verso l’alto if(previousK < previousD && currentK > currentD) { ArrowUpBuffer[j] = Low[j] - (4 * Point); // Regola il valore in base alla tua necessità dello spazio tra la freccia e il prezzo } // Incrocio dall’alto verso il basso if(previousK > previousD && currentK < currentD) { ArrowDownBuffer[j] = High[j] + (4 * Point); // Regola il valore in base alla tua necessità dello spazio tra la freccia e il prezzo }}
return(0); }
string TF2Str(int iPeriod) { switch(iPeriod) { case PERIOD_M1: return("M1"); case PERIOD_M5: return("M5"); case PERIOD_M15: return("M15"); case PERIOD_M30: return("M30"); case PERIOD_H1: return("H1"); case PERIOD_H4: return("H4"); case PERIOD_D1: return("D1"); case PERIOD_W1: return("W1"); case PERIOD_MN1: return("MN1"); default: return("M"+iPeriod); } return(0); }
int GetHigherTimeFrame(int CurrentPeriod ) { if ( CurrentPeriod == 0 ) CurrentPeriod = Period(); if( CurrentPeriod == 1 ) { return(5); } else if( CurrentPeriod == 5 ) { return(15); } else if( CurrentPeriod == 15 ) { return(30); } else if( CurrentPeriod == 30 ) { return(60); } else if( CurrentPeriod == 60 ) { return(240); } else if( CurrentPeriod == 240 ) { return(1440); } else if( CurrentPeriod == 1440 ) { return(10080); } else if( CurrentPeriod == 10080 ) { return(43200); } else if( CurrentPeriod == 43200 ) { return(43200); } } // int GetHigherTimeFrame()
- Assistant
Dal codice fornito, non sembra esserci un errore evidente che potrebbe causare il mancato disegno dello stocastico o delle frecce. Tuttavia, ci potrebbero essere varie ragioni per cui i risultati attesi non si verificano. Ecco alcuni punti che potresti considerare per risolvere il problema:
-
Valori
EMPTY_VALUE: Assicurati che i bufferBufferK,BufferD,BufferK_Curr,BufferD_Curr,ArrowUpBuffereArrowDownBuffersiano correttamente popolati per ciascuna barra. Se ci sono dei valoriEMPTY_VALUE, questi non saranno visualizzati. -
Indicatore Conteggio Barre: Controlla se il calcolo per
countedBars1è corretto e assicurati che i buffer siano riconteggiati correttamente ad ogni tick nuovo o ad ogni aggiornamento del grafico. -
Controllo del Flusso nel Ciclo: Verifica che il ciclo
forper disegnare le frecce abbia l'indice giusto e che i buffer delle frecce vengano impostati correttamente. -
Confronto dei Valori nel Buffer: Per la logica di rilevamento degli incroci, assicurati che i valori di
BufferK_CurreBufferD_Currsiano stati calcolati correttamente. -
Verifica dei Periodi: Il tuo codice gestisce diversi timeframe e fa affidamento su
Period()eTimeFrameper determinare correttamente i valori dello stocastico. Accertati che i periodi usati nelle funzioniiStochasticeiBarShiftsiano quelli che ti aspetti. -
Compilazione: Prova a ricompilare il codice su MT4 per essere sicuro che stia eseguendo l'ultima versione del tuo script senza warning o errori.
-
Impostazioni Grafiche: Assicurati che le impostazioni grafiche dell'indicatore come
SetIndexStyleeSetIndexArrowsiano corrette e che i colori scelti siano visibili sul grafico. -
Visibilità di Stili e Oggetti: Potrebbe succedere che se gli stili sono settati su
DRAW_NONE, questi non verranno mostrati. Inoltre, verifica che l'altezza delle frecce sia sufficientemente distante dal prezzo per essere visibile. -
Valore di
Point: Quando regoli la posizione delle frecce conArrowUpBuffer[j] = Low[j] - (4 * Point);eArrowDownBuffer[j] = High[j] + (4 * Point);, assicurati che il valore diPointsia corretto per il simbolo corrente e che la distanza sia adeguata.
Se dopo aver controllato questi aspetti l'indicatore non funziona ancora correttamente, potrebbe essere utile eseguire il debug passo dopo passo o visualizzare dei messaggi di log nella finestra dell'esperto per avere ulteriori informazioni sullo stato dei calcoli e dei buffer.
-
- User
hai tutto il codice, controlla tu
- Assistant
Chiedo scusa per l'inconveniente. Ho esaminato nuovamente il codice che hai condiviso. Ho notato che nella tua implementazione, due buffer dell'indicatore sono inizialmente impostati con lo stile
DRAW_LINE, ma successivamente, a seconda del valore diHidePctKeHidePctD, lo stile può essere impostato suDRAW_NONE, il che potrebbe effettivamente nascondere le linee dell'oscillatore Stocastico all'interno del grafico separato.Per quanto riguarda le frecce, il codice per le frecce sembra corretto. Tuttavia, ci sono alcune considerazioni da tenere a mente:
-
Presenza di un
continue;inappropriato nel ciclo: Uncontinue;all'inizio della sezione di rilevamento delle intersezioni può causare la mancata valutazione della prima barra dopo l'ultima barra conteggiata, ma al di là di questo, non dovrebbe impedire la visualizzazione delle frecce. -
Pulizia dei buffer delle frecce: I buffer vengono ripuliti ad ogni chiamata della funzione
start(), cosa che dovrebbe essere corretta ma potrebbe generare problemi se le condizioni per disegnare le frecce non si verificano nella barra più recente. -
init()viene chiamato all'interno di se stesso: Questa rigadefault: {TimeFrame = Period(); init(); return(0);}dentro lo switch-case potrebbe causare un ciclo di chiamate ainit(), potenzialmente portando all'uscita precoce dal processo di inizializzazione. Una soluzione potrebbe essere di rimuovere la chiamata ricorsiva ainit()e gestire la situazione in modo diverso.
Con questi punti in considerazione, vorrei suggerire le seguenti correzioni nel codice e vedere se risolve il problema:
-
Rimuovi la chiamata ricorsiva a
init()e gestiscila piuttosto stabilendo un valore predefinito accettabile o notificando l'errore.Sostituisci:
default: {TimeFrame = Period(); init(); return(0);}Con qualcosa del tipo:
default: Print("TimeFrame non valido: " + TimeFrame); return(INIT_FAILED); -
Assicurati che le condizioni per disegnare le frecce non dipendano solo dalla barra corrente, ma anche dai dati storici disponibili. Ad esempio, se la logica attuale richiede che la condizione si verifichi nell'ultima barra disponibile, potrebbe essere necessario espandere questa logica per includere più barre.
-
Verifica che il valore di
Pointsia congruente con il simbolo corrente nel grafico e che le linee e le frecce siano visibili.
Inoltre, il seguente controllo nel ciclo delle frecce sembra essere non richiesto, a meno che non vogliate ignorare esplicitamente l'ultima barra (la barra 0, che è la barra corrente in costruzione):
if(j == 0) continue; // Saltare la barra correnteSe vuoi controllare per la barra corrente, è meglio farlo all'interno del ciclo precedente dove gestisci sia le candele chiuse che la candela corrente.
Se dopo aver esaminato e aggiornato queste aree del codice l'indicatore ancora non mostra le frecce né le linee dello stocastico come previsto, potrebbe essere utile inserire alcune istruzioni di stampa (
Print()) per il debug, permettendo di visualizzare il flusso di esecuzione e i valori delle variabili durante l'esecuzione. Questo può aiutarti a individuare dove le aspettative non corrispondono ai risultati attuali. -
- User
può esserci un problema con i buffers?
- Assistant
Ci potrebbe effettivamente essere un problema con i buffer dell'indicatore se non vengono gestiti correttamente. Ecco alcuni punti chiave da verificare:
-
Buffer Initialization: Assicurati che tutti i buffer siano inizializzati correttamente. Nel codice fornito, i buffer
BufferK,BufferD,BufferK_CurreBufferD_Currsono inizializzati nella funzioneinit(). I buffer delle frecceArrowUpBuffereArrowDownBuffersono anch'essi inizializzati nella funzioneinit(). Questo è corretto. -
Array as Series: I buffer dell'indicatore devono essere impostati come serie usando
ArraySetAsSeries()prima di utilizzarli. Nel tuo codice, questa istruzione è presente per i buffer delle frecce, ma non per i buffer principali. Verifica se questo è intenzionale e, se necessario, aggiungiArraySetAsSeries()anche per gli altri buffer, come segue:ArraySetAsSeries(BufferK, true); ArraySetAsSeries(BufferD, true); ArraySetAsSeries(BufferK_Curr, true); ArraySetAsSeries(BufferD_Curr, true); -
Operazioni di Assegnazione Buffer: Prima di utilizzare i buffer per tracciare i valori sul grafico, devi assegnarli correttamente. Nella funzione
start(), i valori dello stocastico sono calcolati e assegnati ai buffer appropriati. Assicurati che questi valori siano assegnati correttamente e che le barre non siano contate più di una volta tra gli aggiornamenti. -
L'Uso di
EMPTY_VALUE: I buffer sono spesso inizializzati conEMPTY_VALUEper evitare di disegnare dove non ci sono valori da tracciare. Il codice dovrebbe gestire opportunamente l'assegnazione diEMPTY_VALUEquando i valori non sono disponibili. -
Limiti di Indicizzazione dei Buffer: Assicurati di non accedere ai buffer al di fuori dei loro limiti, il che potrebbe causare errori o comportamenti inaspettati.
-
Buffer Pulizia nel Posto Giusto: Nel tuo codice, c'è una pulizia dei buffer delle frecce con
ArrayInitialize()all'inizio distart(). Questo azzera i buffer ad ogni tick, quindi le frecce tracciate potrebbero essere rimosse immediatamente. Per evitare ciò, la pulizia dei buffer dovrebbe essere eseguita in un punto appropriato, ad esempio solo quando è necessario inizializzare o ripulire prima di un riempimento. -
Validità delle Condizioni di Business Logic: Verifica che i tuoi buffer vengano riempiti correttamente in base alla logica di business che desideri implementare. Le condizioni che attivano la popolazione dei buffer delle frecce dovrebbero essere rispettate come previsto.
Se dopo aver verificato e corretto questi aspetti, i buffer sembrano essere gestiti correttamente ma le linee e le frecce continuano a non apparire, dovresti utilizzare il debugger o inserire istruzioni di diagnostica (
Print()oComment()) per individuare dove i valori vengono persi o sovrascritti erroneamente. Questi messaggi possono fornire una visione dettagliata su quali buffer vengono popolati e quali valori contengono in tempo reale durante l'esecuzione dell'indicatore. -
- User
puoi verificarli tu, hai il codice. fallo grazie
- Assistant
I buffer nell'indicatore sono dichiarati e configurati nella funzione
init(). Sembra che manchi l'inizializzazione delle serie per i buffer principaliBufferK,BufferD,BufferK_Curr, eBufferD_Curr. La mancata definizione come serie potrebbe portare a problemi di allineamento quando i buffer vengono aggiornati e potrebbe causare il mancato disegno nel grafico.Per risolvere questo, devi aggiungere
ArraySetAsSeries()immediatamente dopo la definizione di ciascun buffer nell'indicatoreinit()per assicurare la corretta indicizzazione dei buffer. Il codice modificato nellainit()dovrebbe assomigliare a questo://---- indicator buffers SetIndexBuffer(0, BufferK); ArraySetAsSeries(BufferK, true); // Aggiungi questa riga per BufferK SetIndexBuffer(1, BufferD); ArraySetAsSeries(BufferD, true); // Aggiungi questa riga per BufferD SetIndexBuffer(2, BufferK_Curr); ArraySetAsSeries(BufferK_Curr, true); // Aggiungi questa riga per BufferK_Curr SetIndexBuffer(3, BufferD_Curr); ArraySetAsSeries(BufferD_Curr, true); // Aggiungi questa riga per BufferD_Curr SetIndexBuffer(4, ArrowUpBuffer); ArraySetAsSeries(ArrowUpBuffer, true); SetIndexBuffer(5, ArrowDownBuffer); ArraySetAsSeries(ArrowDownBuffer, true);Da notare che per i buffer delle frecce,
ArrowUpBuffereArrowDownBuffer, l'inizializzazione come serie è già presente nel codice che hai fornito.Ho anche notato che nella funzione
start(), c'è una chiamata aArrayInitialize()perArrowUpBuffereArrowDownBufferprima di entrare nel ciclo. Questo pulisce il buffer ad ogni tick, il che è inadatto se ti aspetti che le frecce rimangano visibili. Questa parte del codice può essere rimossa, dato che la popolazione dei buffer delle frecce dovrebbe già gestire correttamente i loro valori.Infine, il ciclo di controllo per le condizioni di incrocio delle linee stocastiche e la creazione delle frecce dovrebbe avvenire dopo che i buffer dello stocastico sono stati pienamente calcolati e non prima.
Il ciclio finale dove le frecce vengono calcolate potrebbe rimanere così:
// Rileva gli incroci e disegna le frecce for(int j = Bars - countedBars1 - 1; j >= 0; j--) { // Verifica la presenza di valori validi prima di disegnare le frecce if(BufferK_Curr[j] == EMPTY_VALUE || BufferD_Curr[j] == EMPTY_VALUE) continue; // Se uno dei valori è EMPTY_VALUE, salta alla prossima iterazione double currentK = BufferK_Curr[j]; double currentD = BufferD_Curr[j]; double previousK = BufferK_Curr[j + 1]; double previousD = BufferD_Curr[j + 1]; // Incrocio dal basso verso l’alto if(previousK < previousD && currentK > currentD) { ArrowUpBuffer[j] = Low[j] - (4 * Point); // Regola il valore in base alla tua necessità dello spazio tra la freccia e il prezzo } // Incrocio dall’alto verso il basso if(previousK > previousD && currentK < currentD) { ArrowDownBuffer[j] = High[j] + (4 * Point); // Regola il valore in base alla tua necessità dello spazio tra la freccia e il prezzo } }Queste correzioni dovrebbero aiutare a garantire che i buffer siano gestiti correttamente e che le frecce e le linee dello stocastico vengano disegnate sul grafico. Ricompila il codice in MT4 e verifica se le modifiche risolvono il problema.
- User
così è corretto secondo le tue indicazioni? //+------------------------------------------------------------------+ //| MTF Stochastic.mq4 | //| 2007, Christof Risch (iya) | //| Stochastic indicator from any timeframe. | //+------------------------------------------------------------------+ // Change Log: // 2.1 2012 07 24 Modified to display only the Signal line (smoothed sma) // cr: 2012 07 20 Added NextHigherAuto to automatically seletc the next higher time frame // Added HidePctD to suppress the Slow line, prn
#property link "http://www.forexfactory.com/showthread.php?t=30109" #property indicator_separate_window #property indicator_buffers 6 #property indicator_color1 Green //C'255,255,255' // White // %K line #property indicator_color2 Red //Yellow // DimGray // %D line #property indicator_color3 Green // C'255,255,255' // White // %K line of the current candle #property indicator_color4 Red //Yellow // DimGray // %D line of the current candle #property indicator_level1 80 #property indicator_level2 20 #property indicator_level3 50 #property indicator_levelcolor DarkSlateGray #property indicator_maximum 100 #property indicator_minimum 0
//---- input parameters extern bool NextHigherAuto = true; extern bool HidePctK = false; extern bool HidePctD = false; extern int TimeFrame = 0, // {1=M1, 5=M5, 15=M15, ..., 1440=D1, 10080=W1, 43200=MN1} KPeriod = 11, DPeriod = 3, Slowing = 3, MAMethod = 0, // {0=SMA, 1=EMA, 2=SMMA, 3=LWMA} PriceField = 0; // {0=Hi/Low, 1=Close/Close} extern bool ShowClock = false; // display time to candle close countdown extern color ClockColor = Red;
//---- indicator buffers double BufferK[], BufferD[], BufferK_Curr[], BufferD_Curr[];
double ArrowUpBuffer[]; double ArrowDownBuffer[]; //---- string IndicatorName = "", TimeLabelName = "";
//+------------------------------------------------------------------+ //| Custom indicator initialization function | //+------------------------------------------------------------------+ int init() { if ( TimeFrame == 0 ) TimeFrame = Period(); if ( NextHigherAuto ) TimeFrame = GetHigherTimeFrame( TimeFrame ) ; //---- name for DataWindow and indicator subwindow label switch(TimeFrame) { case 1: IndicatorName="Period M1"; break; case 5: IndicatorName="Period M5"; break; case 15: IndicatorName="Period M15"; break; case 30: IndicatorName="Period M30"; break; case 60: IndicatorName="Period H1"; break; case 240: IndicatorName="Period H4"; break; case 1440: IndicatorName="Period D1"; break; case 10080: IndicatorName="Period W1"; break; case 43200: IndicatorName="Period MN1"; break; default: {TimeFrame = Period(); init(); return(0);} }
IndicatorName = IndicatorName+" Stoch("+KPeriod+","+DPeriod+","+Slowing+")"; IndicatorShortName(IndicatorName); IndicatorDigits(1);string TimeFrameStr = TF2Str(TimeFrame);
//---- indicator lines SetIndexBuffer(0,BufferK); SetIndexBuffer(1,BufferD); SetIndexBuffer(2,BufferK_Curr); SetIndexBuffer(3,BufferD_Curr); SetIndexStyle(0,DRAW_LINE,EMPTY,1); //SetIndexStyle(0,DRAW_NONE); SetIndexStyle(2,DRAW_LINE,EMPTY,1); //SetIndexStyle(2,DRAW_NONE); if ( ! HidePctK ) { SetIndexStyle(0,DRAW_LINE,EMPTY,1); SetIndexStyle(2,DRAW_LINE,EMPTY,1); SetIndexLabel(0,TimeFrameStr+" %K line"); SetIndexLabel(2,TimeFrameStr+" %K CurrBar"); } else { SetIndexStyle(0,DRAW_NONE); SetIndexStyle(2,DRAW_NONE); SetIndexLabel(0,NULL); SetIndexLabel(2,NULL); }
if ( ! HidePctD ) { SetIndexStyle(1,DRAW_LINE,EMPTY,1); SetIndexStyle(3,DRAW_LINE,EMPTY,1); SetIndexLabel(1,TimeFrameStr+" %D Signal"); SetIndexLabel(3,TimeFrameStr+" %D CurrBar"); } else { SetIndexStyle(1,DRAW_NONE); SetIndexStyle(3,DRAW_NONE); SetIndexLabel(1,NULL); SetIndexLabel(3,NULL); } // Aggiunta dei nuovi buffer per le frecce SetIndexBuffer(4, ArrowUpBuffer); SetIndexArrow(4, SYMBOL_ARROWUP); // Parametro per l’icona freccia verso l’alto (puoi usare l’icona che preferisci) SetIndexStyle(4, DRAW_ARROW); SetIndexLabel(4, "Stochastic Arrow Up");
SetIndexBuffer(5, ArrowDownBuffer); SetIndexArrow(5, SYMBOL_ARROWDOWN); // Parametro per l’icona freccia verso il basso SetIndexStyle(5, DRAW_ARROW); SetIndexLabel(5, "Stochastic Arrow Down");
//---- indicator buffers SetIndexBuffer(0, BufferK); ArraySetAsSeries(BufferK, true); // Aggiungi questa riga per BufferK SetIndexBuffer(1, BufferD); ArraySetAsSeries(BufferD, true); // Aggiungi questa riga per BufferD SetIndexBuffer(2, BufferK_Curr); ArraySetAsSeries(BufferK_Curr, true); // Aggiungi questa riga per BufferK_Curr SetIndexBuffer(3, BufferD_Curr); ArraySetAsSeries(BufferD_Curr, true); // Aggiungi questa riga per BufferD_Curr SetIndexBuffer(4, ArrowUpBuffer); ArraySetAsSeries(ArrowUpBuffer, true); SetIndexBuffer(5, ArrowDownBuffer); ArraySetAsSeries(ArrowDownBuffer, true); } //+------------------------------------------------------------------+ int deinit() { if(TimeLabelName!="") if(ObjectFind (TimeLabelName) != -1) ObjectDelete(TimeLabelName); }
//+------------------------------------------------------------------+ //| MTF Stochastic | //+------------------------------------------------------------------+ int start() { //---- // counted bars from indicator time frame static int countedBars1 = 0;
//---- // counted bars from display time frame if(Bars-1-IndicatorCounted() > 1 && countedBars1!=0) countedBars1 = 0;
int bars1 = iBars(NULL,TimeFrame), start1 = bars1-1-countedBars1, limit1 = iBarShift(NULL,TimeFrame,Time[Bars-1]); if(countedBars1 != bars1-1) { countedBars1 = bars1-1; ArrayInitialize(BufferK_Curr,EMPTY_VALUE); ArrayInitialize(BufferD_Curr,EMPTY_VALUE); if(TimeLabelName!="") if(ObjectFind (TimeLabelName) != -1) ObjectDelete(TimeLabelName); } if(start1 > limit1 && limit1 != -1) start1 = limit1;//---- // 3... 2... 1... GO! for(int i = start1; i >= 0; i--) { int shift1 = i;
if(TimeFrame < Period()) shift1 = iBarShift(NULL,TimeFrame,Time[i]); int time1 = iTime (NULL,TimeFrame,shift1), shift2 = iBarShift(NULL,0,time1); double stochK = iStochastic(NULL,TimeFrame,KPeriod,DPeriod,Slowing,MAMethod,PriceField,0,shift1), stochD = iStochastic(NULL,TimeFrame,KPeriod,DPeriod,Slowing,MAMethod,PriceField,1,shift1); //---- // old (closed) candles if(shift1>=1) { BufferK[shift2] = stochK; BufferD[shift2] = stochD; } //---- // current candle if((TimeFrame >=Period() && shift1<=1) || (TimeFrame < Period() &&(shift1==0||shift2==1))) { BufferK_Curr[shift2] = stochK; BufferD_Curr[shift2] = stochD; } //---- // linear interpolatior for the number of intermediate bars, between two higher timeframe candles. int n = 1; if(TimeFrame > Period()) { int shift2prev = iBarShift(NULL,0,iTime(NULL,TimeFrame,shift1+1)); if(shift2prev!=-1 && shift2prev!=shift2) n = shift2prev - shift2; } //---- // apply interpolation double factor = 1.0 / n; if(shift1>=1) if(BufferK[shift2+n]!=EMPTY_VALUE && BufferK[shift2]!=EMPTY_VALUE) { for(int k = 1; k < n; k++) { BufferK[shift2+k] = k*factor*BufferK[shift2+n] + (1.0-k*factor)*BufferK[shift2]; BufferD[shift2+k] = k*factor*BufferD[shift2+n] + (1.0-k*factor)*BufferD[shift2]; } } //---- // current candle if(shift1==0) if(BufferK_Curr[shift2+n]!=EMPTY_VALUE && BufferK_Curr[shift2]!=EMPTY_VALUE) { for(k = 1; k < n; k++) { BufferK_Curr[shift2+k] = k*factor*BufferK_Curr[shift2+n] + (1.0-k*factor)*BufferK_Curr[shift2]; BufferD_Curr[shift2+k] = k*factor*BufferD_Curr[shift2+n] + (1.0-k*factor)*BufferD_Curr[shift2]; } //---- // candle time countdown if(ShowClock) { int m,s; s = iTime(NULL,TimeFrame,0)+TimeFrame*60 - TimeCurrent(); m = (s-s%60)/60; s = s%60; string text; if(s<10) text = "0"+s; else text = ""+s; text = " "+m+":"+text; int window = WindowFind(IndicatorName); if(window==-1) window = WindowOnDropped() ; TimeLabelName = IndicatorName+" Time Counter "+window; if(ObjectFind (TimeLabelName) == -1) ObjectCreate(TimeLabelName, OBJ_TEXT, window, Time[shift2], BufferK_Curr[shift2]+3); else ObjectMove (TimeLabelName, 0, Time[shift2], BufferK_Curr[shift2]+3); ObjectSetText (TimeLabelName, text, 8, "Verdana", ClockColor); } } }// Rileva gli incroci e disegna le frecce for(int j = Bars - countedBars1 - 1; j >= 0; j--) { // Verifica la presenza di valori validi prima di disegnare le frecce if(BufferK_Curr[j] == EMPTY_VALUE || BufferD_Curr[j] == EMPTY_VALUE) continue; // Se uno dei valori è EMPTY_VALUE, salta alla prossima iterazione
double currentK = BufferK_Curr[j]; double currentD = BufferD_Curr[j]; double previousK = BufferK_Curr[j + 1]; double previousD = BufferD_Curr[j + 1]; // Incrocio dal basso verso l’alto if(previousK < previousD && currentK > currentD) { ArrowUpBuffer[j] = Low[j] - (4 * Point); // Regola il valore in base alla tua necessità dello spazio tra la freccia e il prezzo } // Incrocio dall’alto verso il basso if(previousK > previousD && currentK < currentD) { ArrowDownBuffer[j] = High[j] + (4 * Point); // Regola il valore in base alla tua necessità dello spazio tra la freccia e il prezzo }}
return(0); }
string TF2Str(int iPeriod) { switch(iPeriod) { case PERIOD_M1: return("M1"); case PERIOD_M5: return("M5"); case PERIOD_M15: return("M15"); case PERIOD_M30: return("M30"); case PERIOD_H1: return("H1"); case PERIOD_H4: return("H4"); case PERIOD_D1: return("D1"); case PERIOD_W1: return("W1"); case PERIOD_MN1: return("MN1"); default: return("M"+iPeriod); } return(0); }
int GetHigherTimeFrame(int CurrentPeriod ) { if ( CurrentPeriod == 0 ) CurrentPeriod = Period(); if( CurrentPeriod == 1 ) { return(5); } else if( CurrentPeriod == 5 ) { return(15); } else if( CurrentPeriod == 15 ) { return(30); } else if( CurrentPeriod == 30 ) { return(60); } else if( CurrentPeriod == 60 ) { return(240); } else if( CurrentPeriod == 240 ) { return(1440); } else if( CurrentPeriod == 1440 ) { return(10080); } else if( CurrentPeriod == 10080 ) { return(43200); } else if( CurrentPeriod == 43200 ) { return(43200); } } // int GetHigherTimeFrame()
- Assistant
The code you've included is mostly correct, but there are a few issues that need to be addressed:
-
Duplicate Buffer Definitions: You have defined the indicator buffers twice. Each buffer is assigned with
SetIndexBuffertwo times, which is unnecessary and may cause confusion. You only need to set the index buffer for each buffer once and then callArraySetAsSeriesright after each buffer is assigned. -
Recursive Call in
init(): There's still a recursive call toinit()in theswitch-casestatement. If you intend to keep it for some reason, be very cautious as this may not work as intended in MT4 and can lead to stack overflow or undefined behavior.
Here is the cleaned-up version of the
init()function with the corrections:int init() { if ( TimeFrame == 0 ) TimeFrame = Period(); if ( NextHigherAuto ) TimeFrame = GetHigherTimeFrame( TimeFrame ); switch(TimeFrame) { case 1: IndicatorName="Period M1"; break; case 5: IndicatorName="Period M5"; break; case 15: IndicatorName="Period M15"; break; case 30: IndicatorName="Period M30"; break; case 60: IndicatorName="Period H1"; break; case 240: IndicatorName="Period H4"; break; case 1440: IndicatorName="Period D1"; break; case 10080: IndicatorName="Period W1"; break; case 43200: IndicatorName="Period MN1"; break; default: Print("TimeFrame non valido: " + TimeFrame); return(INIT_FAILED); } IndicatorName = IndicatorName+" Stoch("+KPeriod+","+DPeriod+","+Slowing+")"; IndicatorShortName(IndicatorName); IndicatorDigits(1); string TimeFrameStr = TF2Str(TimeFrame); // Assign buffers SetIndexBuffer(0, BufferK); ArraySetAsSeries(BufferK, true); SetIndexBuffer(1, BufferD); ArraySetAsSeries(BufferD, true); SetIndexBuffer(2, BufferK_Curr); ArraySetAsSeries(BufferK_Curr, true); SetIndexBuffer(3, BufferD_Curr); ArraySetAsSeries(BufferD_Curr, true); SetIndexBuffer(4, ArrowUpBuffer); ArraySetAsSeries(ArrowUpBuffer, true); SetIndexBuffer(5, ArrowDownBuffer); ArraySetAsSeries(ArrowDownBuffer, true); // Define styles and labels based on user settings if (!HidePctK ) { SetIndexStyle(0, DRAW_LINE); SetIndexLabel(0, TimeFrameStr + " %K line"); SetIndexStyle(2, DRAW_LINE); SetIndexLabel(2, TimeFrameStr + " %K CurrBar"); } else { // Do not display the '%K' line if hidden. SetIndexStyle(0, DRAW_NONE); SetIndexLabel(0, NULL); SetIndexStyle(2, DRAW_NONE); SetIndexLabel(2, NULL); } if (!HidePctD ) { SetIndexStyle(1, DRAW_LINE); SetIndexLabel(1, TimeFrameStr + " %D Signal"); SetIndexStyle(3, DRAW_LINE); SetIndexLabel(3, TimeFrameStr + " %D CurrBar"); } else { // Do not display the '%D' line if hidden. SetIndexStyle(1, DRAW_NONE); SetIndexLabel(1, NULL); SetIndexStyle(3, DRAW_NONE); SetIndexLabel(3, NULL); } // Define arrow styles SetIndexStyle(4, DRAW_ARROW); SetIndexArrow(4, SYMBOL_ARROWUP); // Up arrow SetIndexLabel(4, "Stochastic Arrow Up"); SetIndexStyle(5, DRAW_ARROW); SetIndexArrow(5, SYMBOL_ARROWDOWN); // Down arrow SetIndexLabel(5, "Stochastic Arrow Down"); return(INIT_SUCCEEDED); }Remove the extra
SetIndexBufferandArraySetAsSeriescalls, and make sure that the buffer assignment and series declaration only happen once at the beginning of theinit()function. -
- User
//+------------------------------------------------------------------+ //| MTF Stochastic.mq4 | //| 2007, Christof Risch (iya) | //| Stochastic indicator from any timeframe. | //+------------------------------------------------------------------+ // Change Log: // 2.1 2012 07 24 Modified to display only the Signal line (smoothed sma) // cr: 2012 07 20 Added NextHigherAuto to automatically seletc the next higher time frame // Added HidePctD to suppress the Slow line, prn
#property link "http://www.forexfactory.com/showthread.php?t=30109" #property indicator_separate_window #property indicator_buffers 6 #property indicator_color1 Green //C'255,255,255' // White // %K line #property indicator_color2 Red //Yellow // DimGray // %D line #property indicator_color3 Green // C'255,255,255' // White // %K line of the current candle #property indicator_color4 Red //Yellow // DimGray // %D line of the current candle #property indicator_level1 80 #property indicator_level2 20 #property indicator_level3 50 #property indicator_levelcolor DarkSlateGray #property indicator_maximum 100 #property indicator_minimum 0
//---- input parameters extern bool NextHigherAuto = true; extern bool HidePctK = false; extern bool HidePctD = false; extern int TimeFrame = 0, // {1=M1, 5=M5, 15=M15, ..., 1440=D1, 10080=W1, 43200=MN1} KPeriod = 11, DPeriod = 3, Slowing = 3, MAMethod = 0, // {0=SMA, 1=EMA, 2=SMMA, 3=LWMA} PriceField = 0; // {0=Hi/Low, 1=Close/Close} extern bool ShowClock = false; // display time to candle close countdown extern color ClockColor = Red;
//---- indicator buffers double BufferK[], BufferD[], BufferK_Curr[], BufferD_Curr[], ArrowUpBuffer[], ArrowDownBuffer[];
//---- string IndicatorName = "", TimeLabelName = "";
//+------------------------------------------------------------------+ //| Custom indicator initialization function | //+------------------------------------------------------------------+ int init() { if ( TimeFrame == 0 ) TimeFrame = Period(); if ( NextHigherAuto ) TimeFrame = GetHigherTimeFrame( TimeFrame ) ; //---- name for DataWindow and indicator subwindow label switch(TimeFrame) { case 1: IndicatorName="Period M1"; break; case 5: IndicatorName="Period M5"; break; case 15: IndicatorName="Period M15"; break; case 30: IndicatorName="Period M30"; break; case 60: IndicatorName="Period H1"; break; case 240: IndicatorName="Period H4"; break; case 1440: IndicatorName="Period D1"; break; case 10080: IndicatorName="Period W1"; break; case 43200: IndicatorName="Period MN1"; break; default: {TimeFrame = Period(); init(); return(0);} }
IndicatorName = IndicatorName+" Stoch("+KPeriod+","+DPeriod+","+Slowing+")"; IndicatorShortName(IndicatorName); IndicatorDigits(1);string TimeFrameStr = TF2Str(TimeFrame);
//---- indicator lines
SetIndexBuffer(0,BufferK); SetIndexBuffer(1,BufferD); SetIndexBuffer(2,BufferK_Curr); SetIndexBuffer(3,BufferD_Curr); SetIndexStyle(0,DRAW_LINE,EMPTY,1); //SetIndexStyle(0,DRAW_NONE); SetIndexStyle(2,DRAW_LINE,EMPTY,1); //SetIndexStyle(2,DRAW_NONE); if ( ! HidePctK ) { SetIndexStyle(0,DRAW_LINE,EMPTY,1); SetIndexStyle(2,DRAW_LINE,EMPTY,1); SetIndexLabel(0,TimeFrameStr+" %K line"); SetIndexLabel(2,TimeFrameStr+" %K CurrBar"); } else { SetIndexStyle(0,DRAW_NONE); SetIndexStyle(2,DRAW_NONE); SetIndexLabel(0,NULL); SetIndexLabel(2,NULL); }if ( ! HidePctD ) { SetIndexStyle(1,DRAW_LINE,EMPTY,1); SetIndexStyle(3,DRAW_LINE,EMPTY,1); SetIndexLabel(1,TimeFrameStr+" %D Signal"); SetIndexLabel(3,TimeFrameStr+" %D CurrBar"); } else { SetIndexStyle(1,DRAW_NONE); SetIndexStyle(3,DRAW_NONE); SetIndexLabel(1,NULL); SetIndexLabel(3,NULL); }
SetIndexBuffer(4, ArrowUpBuffer);SetIndexArrow(4, SYMBOL_ARROWUP); // Parametro per l’icona freccia verso l’alto (puoi usare l’icona che preferisci) SetIndexStyle(4, DRAW_ARROW); SetIndexLabel(4, "Stochastic Arrow Up"); ArraySetAsSeries(ArrowUpBuffer, true);
SetIndexBuffer(5, ArrowDownBuffer); SetIndexArrow(5, SYMBOL_ARROWDOWN); // Parametro per l’icona freccia verso il basso SetIndexStyle(5, DRAW_ARROW); SetIndexLabel(5, "Stochastic Arrow Down"); ArraySetAsSeries(ArrowDownBuffer, true); }
//+------------------------------------------------------------------+ int deinit() { if(TimeLabelName!="") if(ObjectFind (TimeLabelName) != -1) ObjectDelete(TimeLabelName); }
//+------------------------------------------------------------------+ //| MTF Stochastic | //+------------------------------------------------------------------+ int start() { //---- // counted bars from indicator time frame static int countedBars1 = 0;
//---- // counted bars from display time frame if(Bars-1-IndicatorCounted() > 1 && countedBars1!=0) countedBars1 = 0;
int bars1 = iBars(NULL,TimeFrame), start1 = bars1-1-countedBars1, limit1 = iBarShift(NULL,TimeFrame,Time[Bars-1]); if(countedBars1 != bars1-1) { countedBars1 = bars1-1; ArrayInitialize(BufferK_Curr,EMPTY_VALUE); ArrayInitialize(BufferD_Curr,EMPTY_VALUE); if(TimeLabelName!="") if(ObjectFind (TimeLabelName) != -1) ObjectDelete(TimeLabelName); } if(start1 > limit1 && limit1 != -1) start1 = limit1;//---- // 3... 2... 1... GO! for(int i = start1; i >= 0; i--) { int shift1 = i;
if(TimeFrame < Period()) shift1 = iBarShift(NULL,TimeFrame,Time[i]); int time1 = iTime (NULL,TimeFrame,shift1), shift2 = iBarShift(NULL,0,time1); double stochK = iStochastic(NULL,TimeFrame,KPeriod,DPeriod,Slowing,MAMethod,PriceField,0,shift1), stochD = iStochastic(NULL,TimeFrame,KPeriod,DPeriod,Slowing,MAMethod,PriceField,1,shift1); //---- // old (closed) candles if(shift1>=1) { BufferK[shift2] = stochK; BufferD[shift2] = stochD; } //---- // current candle if((TimeFrame >=Period() && shift1<=1) || (TimeFrame < Period() &&(shift1==0||shift2==1))) { BufferK_Curr[shift2] = stochK; BufferD_Curr[shift2] = stochD; } //---- // linear interpolatior for the number of intermediate bars, between two higher timeframe candles. int n = 1; if(TimeFrame > Period()) { int shift2prev = iBarShift(NULL,0,iTime(NULL,TimeFrame,shift1+1)); if(shift2prev!=-1 && shift2prev!=shift2) n = shift2prev - shift2; } //---- // apply interpolation double factor = 1.0 / n; if(shift1>=1) if(BufferK[shift2+n]!=EMPTY_VALUE && BufferK[shift2]!=EMPTY_VALUE) { for(int k = 1; k < n; k++) { BufferK[shift2+k] = k*factor*BufferK[shift2+n] + (1.0-k*factor)*BufferK[shift2]; BufferD[shift2+k] = k*factor*BufferD[shift2+n] + (1.0-k*factor)*BufferD[shift2]; } } //---- // current candle if(shift1==0) if(BufferK_Curr[shift2+n]!=EMPTY_VALUE && BufferK_Curr[shift2]!=EMPTY_VALUE) { for(k = 1; k < n; k++) { BufferK_Curr[shift2+k] = k*factor*BufferK_Curr[shift2+n] + (1.0-k*factor)*BufferK_Curr[shift2]; BufferD_Curr[shift2+k] = k*factor*BufferD_Curr[shift2+n] + (1.0-k*factor)*BufferD_Curr[shift2]; } //---- // candle time countdown if(ShowClock) { int m,s; s = iTime(NULL,TimeFrame,0)+TimeFrame*60 - TimeCurrent(); m = (s-s%60)/60; s = s%60; string text; if(s<10) text = "0"+s; else text = ""+s; text = " "+m+":"+text; int window = WindowFind(IndicatorName); if(window==-1) window = WindowOnDropped() ; TimeLabelName = IndicatorName+" Time Counter "+window; if(ObjectFind (TimeLabelName) == -1) ObjectCreate(TimeLabelName, OBJ_TEXT, window, Time[shift2], BufferK_Curr[shift2]+3); else ObjectMove (TimeLabelName, 0, Time[shift2], BufferK_Curr[shift2]+3); ObjectSetText (TimeLabelName, text, 8, "Verdana", ClockColor); } } }// Rileva gli incroci e disegna le frecce for(int j = Bars - countedBars1 - 1; j >= 0; j--) { if(j == 0) continue; // Saltare la barra corrente
double currentK = BufferK_Curr[j]; double currentD = BufferD_Curr[j]; double previousK = BufferK_Curr[j + 1]; double previousD = BufferD_Curr[j + 1]; // Incrocio dal basso verso l’alto if(previousK < previousD && currentK > currentD) { ArrowUpBuffer[j] = Low[j] - (4 * Point); // Regola il valore in base alla tua necessità dello spazio tra la freccia e il prezzo } // Incrocio dall’alto verso il basso if(previousK > previousD && currentK < currentD) { ArrowDownBuffer[j] = High[j] + (4 * Point); // Regola il valore in base alla tua necessità dello spazio tra la freccia e il prezzo }} return(0); }
string TF2Str(int iPeriod) { switch(iPeriod) { case PERIOD_M1: return("M1"); case PERIOD_M5: return("M5"); case PERIOD_M15: return("M15"); case PERIOD_M30: return("M30"); case PERIOD_H1: return("H1"); case PERIOD_H4: return("H4"); case PERIOD_D1: return("D1"); case PERIOD_W1: return("W1"); case PERIOD_MN1: return("MN1"); default: return("M"+iPeriod); } return(0); }
int GetHigherTimeFrame(int CurrentPeriod ) { if ( CurrentPeriod == 0 ) CurrentPeriod = Period(); if( CurrentPeriod == 1 ) { return(5); } else if( CurrentPeriod == 5 ) { return(15); } else if( CurrentPeriod == 15 ) { return(30); } else if( CurrentPeriod == 30 ) { return(60); } else if( CurrentPeriod == 60 ) { return(240); } else if( CurrentPeriod == 240 ) { return(1440); } else if( CurrentPeriod == 1440 ) { return(10080); } else if( CurrentPeriod == 10080 ) { return(43200); } else if( CurrentPeriod == 43200 ) { return(43200); } } // int GetHigherTimeFrame()
non mostra nulla sul grafico
- Assistant
Dopo aver analizzato nuovamente il tuo codice, ecco alcune possibili ragioni per cui l'indicatore potrebbe non mostrare nulla sul grafico di MetaTrader 4 (MT4):
-
Settings di TimeFrame non corretti: Il seguente pezzo di codice all'interno della funzione
init()può potenzialmente causare un ciclo infinito se ilTimeFramefornito dal parametro esterno non corrisponde a nessuno dei casi:default: {TimeFrame = Period(); init(); return(0);}Questo chiamerà
init()ricorsivamente, fino a quandoTimeFramecorrisponde a un valore accettato. Tieni presente che i timeframe personalizzati non standard possono non funzionare correttamente con questo codice. -
Il mancato uso di ArraySetAsSeries(): Manca la chiamata di
ArraySetAsSeries()per i bufferBufferK,BufferD,BufferK_Curr, eBufferD_Curr.I buffer devono essere impostati come serie cronologica per assicurarsi che l'indicizzazione funzioni correttamente all'interno delle funzioni di MT4, soprattutto se lavori con i dati delle barre precedenti. Pertanto, aggiungi dopo ogni chiamata
SetIndexBufferininit():ArraySetAsSeries(BufferK, true); ArraySetAsSeries(BufferD, true); ArraySetAsSeries(BufferK_Curr, true); ArraySetAsSeries(BufferD_Curr, true); -
Errore di logica durante il rilevamento delle incroci:
È possibile che la logica utilizzata per identificare gli incroci e posizionare le frecce non sia corretta o che le condizioni non vengano mai soddisfatte. Assicurati che le condizioni per il posizionamento delle frecce seguano le corrette regole dello Stocastico e che ci siano effettivamente incroci.
-
Punto di inserimento delle frecce:
Le frecce vengono posizionate a una distanza troppo lontana dal prezzo corrente (4 punti sopra o sotto). Se il valore del simbolo è grande, le frecce potrebbero risultare fuori dallo schermo. Prova a ridurre questa distanza o adattarla in base alla scala del prezzo del simbolo in esame.
ArrowUpBuffer[j] = Low[j] - (0.001 * Point); // Adatta questa distanza ArrowDownBuffer[j] = High[j] + (0.001 * Point); // Adatta questa distanza -
Possibile errore di sincronizzazione tra i timeframe:
Potrebbe esserci un errore nella sincronizzazione tra il timeframe del grafico e quello che l'indicatore sta cercando di utilizzare per il calcolo dello Stocastico. Ciò può accadere se
iBarShifto altre funzioni correlate non vengono utilizzate correttamente.
Risolvere questi problemi potrebbe già essere sufficiente per ottenere un funzionamento corretto dell'indicatore. Ricontrolla il codice con attenzione e assicurati che tutto sia in ordine. Se persistono problemi, considera di fare un debugging più approfondito o di usare messaggi di log (
Print()) per tracciare i valori intermedi e comprendere meglio cosa non funziona. -
- User
scrivi il blocco del codice contentente la correzione al punto 2
- Assistant
Certo, ecco le correzioni al punto 2 per l'inizializzazione dei buffer. Devi aggiungere le chiamate
ArraySetAsSeriessubito dopo aver impostato ciascun buffer conSetIndexBuffernella funzioneinit().Ecco il blocco di codice corretto:
int init() { //...[omitted rest of the init code before the buffers]... //---- indicator lines SetIndexBuffer(0, BufferK); ArraySetAsSeries(BufferK, true); // Set BufferK as a time series SetIndexBuffer(1, BufferD); ArraySetAsSeries(BufferD, true); // Set BufferD as a time series SetIndexBuffer(2, BufferK_Curr); ArraySetAsSeries(BufferK_Curr, true); // Set BufferK_Curr as a time series SetIndexBuffer(3, BufferD_Curr); ArraySetAsSeries(BufferD_Curr, true); // Set BufferD_Curr as a time series // Set Index Styles and properties for %K and %D lines (will continue from your code) //...[omitted rest of the init code after the buffers]... return(INIT_SUCCEEDED); }Assicurati di includere queste righe nel giusto punto della funzione
init(), subito dopo aver impostato ciascun buffer con la funzioneSetIndexBuffer(). Non saranno necessarie ulteriori modifiche a meno che tu non stia riscontrando altri problemi specifici con il tuo indicatore. Ricompila dopo aver effettuato queste modifiche e verifica se il comportamento dell'indicatore migliora. - User
riscrivi tutto int init
- Assistant
Ecco la funzione
init()rivista includendo le correzioni necessarie secondo la tua richiesta, inclusa l'inizializzazione corretta dei buffer conArraySetAsSeries():int init() { if (TimeFrame == 0) TimeFrame = Period(); if (NextHigherAuto) TimeFrame = GetHigherTimeFrame(TimeFrame); // name for DataWindow and indicator subwindow label switch(TimeFrame) { case PERIOD_M1: IndicatorName="Period M1"; break; case PERIOD_M5: IndicatorName="Period M5"; break; case PERIOD_M15: IndicatorName="Period M15"; break; case PERIOD_M30: IndicatorName="Period M30"; break; case PERIOD_H1: IndicatorName="Period H1"; break; case PERIOD_H4: IndicatorName="Period H4"; break; case PERIOD_D1: IndicatorName="Period D1"; break; case PERIOD_W1: IndicatorName="Period W1"; break; case PERIOD_MN1: IndicatorName="Period MN1"; break; default: Print("TimeFrame non valido: " + TimeFrame); return(INIT_FAILED); // Removed the recursive call to init() for safety. } IndicatorName = IndicatorName + " Stoch(" + KPeriod + "," + DPeriod + "," + Slowing + ")"; IndicatorShortName(IndicatorName); IndicatorDigits(1); string TimeFrameStr = TF2Str(TimeFrame); //---- set indicator buffers SetIndexBuffer(0, BufferK); ArraySetAsSeries(BufferK, true); SetIndexBuffer(1, BufferD); ArraySetAsSeries(BufferD, true); SetIndexBuffer(2, BufferK_Curr); ArraySetAsSeries(BufferK_Curr, true); SetIndexBuffer(3, BufferD_Curr); ArraySetAsSeries(BufferD_Curr, true); SetIndexBuffer(4, ArrowUpBuffer); ArraySetAsSeries(ArrowUpBuffer, true); SetIndexBuffer(5, ArrowDownBuffer); ArraySetAsSeries(ArrowDownBuffer, true); //---- set index draw begin and styles according to HidePctK and HidePctD if (!HidePctK) { SetIndexStyle(0, DRAW_LINE, EMPTY, 1); SetIndexLabel(0, TimeFrameStr + " %K line"); SetIndexStyle(2, DRAW_LINE, EMPTY, 1); SetIndexLabel(2, TimeFrameStr + " %K CurrBar"); } else { SetIndexStyle(0, DRAW_NONE); SetIndexLabel(0, NULL); SetIndexStyle(2, DRAW_NONE); SetIndexLabel(2, NULL); } if (!HidePctD) { SetIndexStyle(1, DRAW_LINE, EMPTY, 1); SetIndexLabel(1, TimeFrameStr + " %D Signal"); SetIndexStyle(3, DRAW_LINE, EMPTY, 1); SetIndexLabel(3, TimeFrameStr + " %D CurrBar"); } else { SetIndexStyle(1, DRAW_NONE); SetIndexLabel(1, NULL); SetIndexStyle(3, DRAW_NONE); SetIndexLabel(3, NULL); } //---- arrows settings SetIndexArrow(4, SYMBOL_ARROWUP); SetIndexStyle(4, DRAW_ARROW); SetIndexLabel(4, "Stochastic Arrow Up"); SetIndexArrow(5, SYMBOL_ARROWDOWN); SetIndexStyle(5, DRAW_ARROW); SetIndexLabel(5, "Stochastic Arrow Down"); return(INIT_SUCCEEDED); }Assicurati di integrare correttamente questo codice con il resto delle tue funzioni nel file dell'indicatore. Ricompila l'indicatore dopo aver effettuato le modifiche per verificarne il funzionamento.
- User
questo era il codice originale funzionante. trova le differenze, il mio non disegna nulla //+------------------------------------------------------------------+ //| MTF Stochastic.mq4 | //| 2007, Christof Risch (iya) | //| Stochastic indicator from any timeframe. | //+------------------------------------------------------------------+ // Change Log: // 2.1 2012 07 24 Modified to display only the Signal line (smoothed sma) // cr: 2012 07 20 Added NextHigherAuto to automatically seletc the next higher time frame // Added HidePctD to suppress the Slow line, prn
#property link "http://www.forexfactory.com/showthread.php?t=30109" #property indicator_separate_window #property indicator_buffers 4 #property indicator_color1 Green //C'255,255,255' // White // %K line #property indicator_color2 Red //Yellow // DimGray // %D line #property indicator_color3 Green // C'255,255,255' // White // %K line of the current candle #property indicator_color4 Red //Yellow // DimGray // %D line of the current candle #property indicator_level1 80 #property indicator_level2 20 #property indicator_level3 50 #property indicator_levelcolor DarkSlateGray #property indicator_maximum 100 #property indicator_minimum 0
//---- input parameters extern bool NextHigherAuto = true; extern bool HidePctK = false; extern bool HidePctD = false; extern int TimeFrame = 0, // {1=M1, 5=M5, 15=M15, ..., 1440=D1, 10080=W1, 43200=MN1} KPeriod = 11, DPeriod = 3, Slowing = 3, MAMethod = 0, // {0=SMA, 1=EMA, 2=SMMA, 3=LWMA} PriceField = 0; // {0=Hi/Low, 1=Close/Close} extern bool ShowClock = false; // display time to candle close countdown extern color ClockColor = Red;
//---- indicator buffers double BufferK[], BufferD[], BufferK_Curr[], BufferD_Curr[];
//---- string IndicatorName = "", TimeLabelName = "";
//+------------------------------------------------------------------+ //| Custom indicator initialization function | //+------------------------------------------------------------------+ int init() { if ( TimeFrame == 0 ) TimeFrame = Period(); if ( NextHigherAuto ) TimeFrame = GetHigherTimeFrame( TimeFrame ) ; //---- name for DataWindow and indicator subwindow label switch(TimeFrame) { case 1: IndicatorName="Period M1"; break; case 5: IndicatorName="Period M5"; break; case 15: IndicatorName="Period M15"; break; case 30: IndicatorName="Period M30"; break; case 60: IndicatorName="Period H1"; break; case 240: IndicatorName="Period H4"; break; case 1440: IndicatorName="Period D1"; break; case 10080: IndicatorName="Period W1"; break; case 43200: IndicatorName="Period MN1"; break; default: {TimeFrame = Period(); init(); return(0);} }
IndicatorName = IndicatorName+" Stoch("+KPeriod+","+DPeriod+","+Slowing+")"; IndicatorShortName(IndicatorName); IndicatorDigits(1);string TimeFrameStr = TF2Str(TimeFrame);
//---- indicator lines SetIndexBuffer(0,BufferK); SetIndexBuffer(1,BufferD); SetIndexBuffer(2,BufferK_Curr); SetIndexBuffer(3,BufferD_Curr); SetIndexStyle(0,DRAW_LINE,EMPTY,1); //SetIndexStyle(0,DRAW_NONE); SetIndexStyle(2,DRAW_LINE,EMPTY,1); //SetIndexStyle(2,DRAW_NONE); if ( ! HidePctK ) { SetIndexStyle(0,DRAW_LINE,EMPTY,1); SetIndexStyle(2,DRAW_LINE,EMPTY,1); SetIndexLabel(0,TimeFrameStr+" %K line"); SetIndexLabel(2,TimeFrameStr+" %K CurrBar"); } else { SetIndexStyle(0,DRAW_NONE); SetIndexStyle(2,DRAW_NONE); SetIndexLabel(0,NULL); SetIndexLabel(2,NULL); }
if ( ! HidePctD ) { SetIndexStyle(1,DRAW_LINE,EMPTY,1); SetIndexStyle(3,DRAW_LINE,EMPTY,1); SetIndexLabel(1,TimeFrameStr+" %D Signal"); SetIndexLabel(3,TimeFrameStr+" %D CurrBar"); } else { SetIndexStyle(1,DRAW_NONE); SetIndexStyle(3,DRAW_NONE); SetIndexLabel(1,NULL); SetIndexLabel(3,NULL); } }
//+------------------------------------------------------------------+ int deinit() { if(TimeLabelName!="") if(ObjectFind (TimeLabelName) != -1) ObjectDelete(TimeLabelName); }
//+------------------------------------------------------------------+ //| MTF Stochastic | //+------------------------------------------------------------------+ int start() { //---- // counted bars from indicator time frame static int countedBars1 = 0;
//---- // counted bars from display time frame if(Bars-1-IndicatorCounted() > 1 && countedBars1!=0) countedBars1 = 0;
int bars1 = iBars(NULL,TimeFrame), start1 = bars1-1-countedBars1, limit1 = iBarShift(NULL,TimeFrame,Time[Bars-1]); if(countedBars1 != bars1-1) { countedBars1 = bars1-1; ArrayInitialize(BufferK_Curr,EMPTY_VALUE); ArrayInitialize(BufferD_Curr,EMPTY_VALUE); if(TimeLabelName!="") if(ObjectFind (TimeLabelName) != -1) ObjectDelete(TimeLabelName); } if(start1 > limit1 && limit1 != -1) start1 = limit1;//---- // 3... 2... 1... GO! for(int i = start1; i >= 0; i--) { int shift1 = i;
if(TimeFrame < Period()) shift1 = iBarShift(NULL,TimeFrame,Time[i]); int time1 = iTime (NULL,TimeFrame,shift1), shift2 = iBarShift(NULL,0,time1); double stochK = iStochastic(NULL,TimeFrame,KPeriod,DPeriod,Slowing,MAMethod,PriceField,0,shift1), stochD = iStochastic(NULL,TimeFrame,KPeriod,DPeriod,Slowing,MAMethod,PriceField,1,shift1); //---- // old (closed) candles if(shift1>=1) { BufferK[shift2] = stochK; BufferD[shift2] = stochD; } //---- // current candle if((TimeFrame >=Period() && shift1<=1) || (TimeFrame < Period() &&(shift1==0||shift2==1))) { BufferK_Curr[shift2] = stochK; BufferD_Curr[shift2] = stochD; } //---- // linear interpolatior for the number of intermediate bars, between two higher timeframe candles. int n = 1; if(TimeFrame > Period()) { int shift2prev = iBarShift(NULL,0,iTime(NULL,TimeFrame,shift1+1)); if(shift2prev!=-1 && shift2prev!=shift2) n = shift2prev - shift2; } //---- // apply interpolation double factor = 1.0 / n; if(shift1>=1) if(BufferK[shift2+n]!=EMPTY_VALUE && BufferK[shift2]!=EMPTY_VALUE) { for(int k = 1; k < n; k++) { BufferK[shift2+k] = k*factor*BufferK[shift2+n] + (1.0-k*factor)*BufferK[shift2]; BufferD[shift2+k] = k*factor*BufferD[shift2+n] + (1.0-k*factor)*BufferD[shift2]; } } //---- // current candle if(shift1==0) if(BufferK_Curr[shift2+n]!=EMPTY_VALUE && BufferK_Curr[shift2]!=EMPTY_VALUE) { for(k = 1; k < n; k++) { BufferK_Curr[shift2+k] = k*factor*BufferK_Curr[shift2+n] + (1.0-k*factor)*BufferK_Curr[shift2]; BufferD_Curr[shift2+k] = k*factor*BufferD_Curr[shift2+n] + (1.0-k*factor)*BufferD_Curr[shift2]; } //---- // candle time countdown if(ShowClock) { int m,s; s = iTime(NULL,TimeFrame,0)+TimeFrame*60 - TimeCurrent(); m = (s-s%60)/60; s = s%60; string text; if(s<10) text = "0"+s; else text = ""+s; text = " "+m+":"+text; int window = WindowFind(IndicatorName); if(window==-1) window = WindowOnDropped() ; TimeLabelName = IndicatorName+" Time Counter "+window; if(ObjectFind (TimeLabelName) == -1) ObjectCreate(TimeLabelName, OBJ_TEXT, window, Time[shift2], BufferK_Curr[shift2]+3); else ObjectMove (TimeLabelName, 0, Time[shift2], BufferK_Curr[shift2]+3); ObjectSetText (TimeLabelName, text, 8, "Verdana", ClockColor); } } } return(0);}
string TF2Str(int iPeriod) { switch(iPeriod) { case PERIOD_M1: return("M1"); case PERIOD_M5: return("M5"); case PERIOD_M15: return("M15"); case PERIOD_M30: return("M30"); case PERIOD_H1: return("H1"); case PERIOD_H4: return("H4"); case PERIOD_D1: return("D1"); case PERIOD_W1: return("W1"); case PERIOD_MN1: return("MN1"); default: return("M"+iPeriod); } return(0); }
int GetHigherTimeFrame(int CurrentPeriod ) { if ( CurrentPeriod == 0 ) CurrentPeriod = Period(); if( CurrentPeriod == 1 ) { return(5); } else if( CurrentPeriod == 5 ) { return(15); } else if( CurrentPeriod == 15 ) { return(30); } else if( CurrentPeriod == 30 ) { return(60); } else if( CurrentPeriod == 60 ) { return(240); } else if( CurrentPeriod == 240 ) { return(1440); } else if( CurrentPeriod == 1440 ) { return(10080); } else if( CurrentPeriod == 10080 ) { return(43200); } else if( CurrentPeriod == 43200 ) { return(43200); } } // int GetHigherTimeFrame()
- Assistant
Analizzando il codice funzionante del tuo indicatore MTF Stochastic rispetto ai tentativi di modifica precedenti, ecco le differenze e le possibili ragioni per cui l'indicatore modificato non disegna nulla sul grafico:
-
Numero di buffer: Il codice originale dichiara
#property indicator_buffers 4mentre le versioni modificate hanno#property indicator_buffers 6. L'aumento dei buffer potrebbe essere stato una modifica non necessaria se non hai aggiunto funzionalità che richiedono buffer aggiuntivi. -
Chiamata ricorsiva: La funzione
init()nel codice originale ha una chiamata ricorsiva a se stessa con la rigadefault: {TimeFrame = Period(); init(); return(0);}all'interno dello switch-case per impostare ilTimeFrame. Ciò può essere pericoloso poiché potrebbe causare un loop infinito, tuttavia, se il codice originale era funzionante, significa che questa chiamata ricorsiva non ha causato problemi. Nelle versioni modificate, questa chiamata è stata rimossa o modificata. -
ArraySetAsSeries(): Il codice originale non utilizza
ArraySetAsSeries()per i bufferBufferK,BufferD,BufferK_CurreBufferD_Curr, il che suggerisce che l'indicatore originale funzionava senza che questi buffer fossero trattati esplicitamente come serie temporali. Questo può essere perché la piattaforma MT4 potrebbe gestire correttamente i buffer senza bisogno di questa chiamata in alcune situazioni. -
Mancato aggiornamento del buffer delle frecce: Nel tentativo di modifica del codice, sono stati aggiunti due nuovi buffer per le frecce (
ArrowUpBuffereArrowDownBuffer), ma non c'è la logica per aggiornarli nel corpo della funzionestart(). Se l'obiettivo era aggiungere frecce al grafico, avresti dovuto includere il codice per settare i valori di questi buffer quando avviene un incrocio dello Stochastic. -
Init dei buffer nel ciclo: Un'altra differenza nel codice originale è che i buffer
BufferK_CurreBufferD_Currsono inizializzati aEMPTY_VALUEall'inizio di ogni chiamata alla funzionestart(), mentre nei tentativi di modifica, questo è stato rimosso.
Per riportare l'indicatore a uno stato funzionante simile al codice originale, dovrai:
- Cambiare
#property indicator_buffersal numero corretto di buffer che stai effettivamente utilizzando. - Rimuovere i buffer extra se non sono necessari.
- Assicurarti che eventuali nuove funzionalità, come le frecce, vengano implementate correttamente.
- Valuta se è necessario o meno utilizzare
ArraySetAsSeriesbasandoti sulla versione MT4 e sul comportamento osservato. In generale, è buona pratica utilizzareArraySetAsSeriesquando si lavora con buffer, ma se rimuovi quella logica, l'indicatore deve comportarsi come il codice originale.
Se la versione modificata dell'indicatore deve includere funzionalità aggiuntive (come le frecce), assicurati di completare la logica nella funzione
start()per gestire correttamente i nuovi buffer. -
- User
ok. scrivi la funzione start per intero con l'aggiunta delle frecce
- Assistant
Per aggiungere frecce all'indicatore esistente, dobbiamo prima stabilire in quali condizioni queste frecce dovrebbero essere mostrate. Tipicamente, le frecce stocastiche sono mostrate quando il %K incrocia il %D da sopra a sotto per una freccia verso il basso (vendita) e da sotto a sopra per una freccia verso l'alto (acquisto). Il seguente esempio di codice implementa questa logica nella funzione
start():int start() { int counted_bars = IndicatorCounted(); if(counted_bars < 0) return(-1); if(counted_bars > 0) counted_bars--; int limit = Bars - counted_bars; for(int i = limit; i >= 0; i--) { double currentK = iStochastic(NULL, TimeFrame, KPeriod, DPeriod, Slowing, MAMethod, PriceField, MODE_MAIN, i); double currentD = iStochastic(NULL, TimeFrame, KPeriod, DPeriod, Slowing, MAMethod, PriceField, MODE_SIGNAL, i); // Per evitare valori di buffer non validi nei calcoli successivi if(i == 0 || i == 1) { BufferK_Curr[i] = currentK; BufferD_Curr[i] = currentD; continue; } // Salva i valori precendenti per confronto double previousK = BufferK_Curr[i + 1]; double previousD = BufferD_Curr[i + 1]; // Popolare il buffer BufferK[i] = currentK; BufferD[i] = currentD; // Questo è per la barra attuale (0) e la barra appena chiusa (1) BufferK_Curr[i] = currentK; BufferD_Curr[i] = currentD; // Incrocio dal basso verso l'alto (%K incrocia %D verso l'alto) if(currentK > currentD && previousK <= previousD) { ArrowUpBuffer[i] = Low[i] - (4 * Point); } // Incrocio dall'alto verso il basso (%K incrocia %D verso il basso) else if(currentK < currentD && previousK >= previousD) { ArrowDownBuffer[i] = High[i] + (4 * Point); } // Se non c'è un incrocio, assicurarsi che il buffer delle frecce sia EMPTY_VALUE else { ArrowUpBuffer[i] = EMPTY_VALUE; ArrowDownBuffer[i] = EMPTY_VALUE; } } return(0); }Assicurati che le seguenti righe siano presenti nel tuo metodo
init()per essere in grado di vedere queste frecce:SetIndexBuffer(4, ArrowUpBuffer); SetIndexBuffer(5, ArrowDownBuffer); SetIndexArrow(4, SYMBOL_ARROWUP); SetIndexArrow(5, SYMBOL_ARROWDOWN);L'uso della variabile
counted_barse del “limit” è stato fatto per garantire l'efficienza durante il calcolo, evitando di ricalcolare valori per barre che sono già state contate in precedenti tick.Questo codice di esempio ha un valore arbitrario di distanza (4 volte il
Point) per la posizione delle frecce al di sotto del minimo e al di sopra del massimo delle barre. Potresti dover regolare questi valori a seconda della scala dei prezzi del tuo grafico e della dimensione del punto per la coppia di valute che stai scambiando. - User
questa è la funzione start originale, mi sembra manchi qualche pezzo int start() { //---- // counted bars from indicator time frame static int countedBars1 = 0;
//---- // counted bars from display time frame if(Bars-1-IndicatorCounted() > 1 && countedBars1!=0) countedBars1 = 0;
int bars1 = iBars(NULL,TimeFrame), start1 = bars1-1-countedBars1, limit1 = iBarShift(NULL,TimeFrame,Time[Bars-1]); if(countedBars1 != bars1-1) { countedBars1 = bars1-1; ArrayInitialize(BufferK_Curr,EMPTY_VALUE); ArrayInitialize(BufferD_Curr,EMPTY_VALUE); if(TimeLabelName!="") if(ObjectFind (TimeLabelName) != -1) ObjectDelete(TimeLabelName); } if(start1 > limit1 && limit1 != -1) start1 = limit1;//---- // 3... 2... 1... GO! for(int i = start1; i >= 0; i--) { int shift1 = i;
if(TimeFrame < Period()) shift1 = iBarShift(NULL,TimeFrame,Time[i]); int time1 = iTime (NULL,TimeFrame,shift1), shift2 = iBarShift(NULL,0,time1); double stochK = iStochastic(NULL,TimeFrame,KPeriod,DPeriod,Slowing,MAMethod,PriceField,0,shift1), stochD = iStochastic(NULL,TimeFrame,KPeriod,DPeriod,Slowing,MAMethod,PriceField,1,shift1); //---- // old (closed) candles if(shift1>=1) { BufferK[shift2] = stochK; BufferD[shift2] = stochD; } //---- // current candle if((TimeFrame >=Period() && shift1<=1) || (TimeFrame < Period() &&(shift1==0||shift2==1))) { BufferK_Curr[shift2] = stochK; BufferD_Curr[shift2] = stochD; } //---- // linear interpolatior for the number of intermediate bars, between two higher timeframe candles. int n = 1; if(TimeFrame > Period()) { int shift2prev = iBarShift(NULL,0,iTime(NULL,TimeFrame,shift1+1)); if(shift2prev!=-1 && shift2prev!=shift2) n = shift2prev - shift2; } //---- // apply interpolation double factor = 1.0 / n; if(shift1>=1) if(BufferK[shift2+n]!=EMPTY_VALUE && BufferK[shift2]!=EMPTY_VALUE) { for(int k = 1; k < n; k++) { BufferK[shift2+k] = k*factor*BufferK[shift2+n] + (1.0-k*factor)*BufferK[shift2]; BufferD[shift2+k] = k*factor*BufferD[shift2+n] + (1.0-k*factor)*BufferD[shift2]; } } //---- // current candle if(shift1==0) if(BufferK_Curr[shift2+n]!=EMPTY_VALUE && BufferK_Curr[shift2]!=EMPTY_VALUE) { for(k = 1; k < n; k++) { BufferK_Curr[shift2+k] = k*factor*BufferK_Curr[shift2+n] + (1.0-k*factor)*BufferK_Curr[shift2]; BufferD_Curr[shift2+k] = k*factor*BufferD_Curr[shift2+n] + (1.0-k*factor)*BufferD_Curr[shift2]; } //---- // candle time countdown if(ShowClock) { int m,s; s = iTime(NULL,TimeFrame,0)+TimeFrame*60 - TimeCurrent(); m = (s-s%60)/60; s = s%60; string text; if(s<10) text = "0"+s; else text = ""+s; text = " "+m+":"+text; int window = WindowFind(IndicatorName); if(window==-1) window = WindowOnDropped() ; TimeLabelName = IndicatorName+" Time Counter "+window; if(ObjectFind (TimeLabelName) == -1) ObjectCreate(TimeLabelName, OBJ_TEXT, window, Time[shift2], BufferK_Curr[shift2]+3); else ObjectMove (TimeLabelName, 0, Time[shift2], BufferK_Curr[shift2]+3); ObjectSetText (TimeLabelName, text, 8, "Verdana", ClockColor); } } }// Rileva gli incroci e disegna le frecce for(int j = Bars - countedBars1 - 1; j >= 0; j--) { // Verifica la presenza di valori validi prima di disegnare le frecce if(BufferK_Curr[j] == EMPTY_VALUE || BufferD_Curr[j] == EMPTY_VALUE) continue; // Se uno dei valori è EMPTY_VALUE, salta alla prossima iterazione
double currentK = BufferK_Curr[j]; double currentD = BufferD_Curr[j]; double previousK = BufferK_Curr[j + 1]; double previousD = BufferD_Curr[j + 1]; // Incrocio dal basso verso l’alto if(previousK < previousD && currentK > currentD) { ArrowUpBuffer[j] = Low[j] - (4 * Point); // Regola il valore in base alla tua necessità dello spazio tra la freccia e il prezzo } // Incrocio dall’alto verso il basso if(previousK > previousD && currentK < currentD) { ArrowDownBuffer[j] = High[j] + (4 * Point); // Regola il valore in base alla tua necessità dello spazio tra la freccia e il prezzo }}
return(0); }
- Assistant
Alla fine della funzione
start()fornita, è presente un segmento di codice che tenta di identificare gli incroci tra la linea %K e la linea %D dello stocastico e di disegnare le frecce di conseguenza. Tuttavia, per far sì che le frecce siano visibili sul grafico, è necessario che i bufferArrowUpBuffereArrowDownBuffersiano configurati correttamente nella funzioneinit(). Dovresti anche dichiarare i buffer delle frecce nel tuo codice.Ecco il codice completo di
start()modificato per includere correttamente le frecce:int start() { // Variabile per conteggiare il numero di barre già calcolate int counted_bars = IndicatorCounted(); // Se c'è un errore, esce if(counted_bars < 0) return(-1); // Riduce il numero di barre per il calcolo se è stata aggiunta una nuova barra if(counted_bars > 0) counted_bars--; int limit = Bars - counted_bars; // Ciclo attraverso le barre non conteggiate for(int i = limit; i >= 0; i--) { BufferK[i] = iStochastic(NULL, TimeFrame, KPeriod, DPeriod, Slowing, MAMethod, PriceField, MODE_MAIN, i); BufferD[i] = iStochastic(NULL, TimeFrame, KPeriod, DPeriod, Slowing, MAMethod, PriceField, MODE_SIGNAL, i); // Per evitare l'accesso a valori non esistenti ad i-1 quando i è 0 if(i == 0) continue; // Regola per le frecce verso l’alto if(BufferK[i] > BufferD[i] && BufferK[i-1] <= BufferD[i-1]) { ArrowUpBuffer[i] = Low[i] - (4 * Point); // Valori di esempio, regolare se necessario ArrowDownBuffer[i] = EMPTY_VALUE; // Assicurarsi di svuotare il buffer delle frecce verso il basso } // Regola per le frecce verso il basso else if(BufferK[i] < BufferD[i] && BufferK[i-1] >= BufferD[i-1]) { ArrowDownBuffer[i] = High[i] + (4 * Point); // Valori di esempio, regolare se necessario ArrowUpBuffer[i] = EMPTY_VALUE; // Assicurarsi di svuotare il buffer delle frecce verso l'alto } else { // Se non c'è incrocio, svuotiamo i buffer delle frecce ArrowUpBuffer[i] = EMPTY_VALUE; ArrowDownBuffer[i] = EMPTY_VALUE; } } return(0); }Nota che in questo codice, ho incluso la logica per disegnare le frecce all'interno del ciclo principale in cui vengono calcolati i valori dello stocastico. Ho anche aggiunto una condizione per non eseguire il controllo sull'ultima barra (quando
i == 0) dal momento che in MT4 l'ultima barra è in formazione e può causare segnali falsi o errati.Se l'obiettivo è visualizzare le frecce rispetto alla barra in corso (current bar), sarà necessario considerare un approccio leggermente diverso che analizzi la barra corrente rispetto al comportamento dello stocastico.
Inoltre, assicurati che i buffer
ArrowUpBuffereArrowDownBuffersiano impostati nella funzioneinit()come segue:SetIndexBuffer(4, ArrowUpBuffer); SetIndexBuffer(5, ArrowDownBuffer);Senza questi completamenti, le frecce non saranno visibili sul grafico.
- User
la tua funzione start non è completa. riscrivila completa
- Assistant
Chiedo scusa per l'inconveniente. Ti fornirò la versione completa e corretta della funzione
start()che include l'aggiunta delle frecce sulla base del codice originale e della logica fornita precedentemente:int start() { // Conteggio di barre già elaborate static int countedBars1 = 0; // Controlla il necessario aggiornamento dei dati if(Bars - IndicatorCounted() > 1 && countedBars1 != 0) countedBars1 = 0; // Calcolo delle barre necessario per il time frame dell'indicatore int bars1 = iBars(NULL, TimeFrame), start1 = bars1 - 1 - countedBars1, limit1 = iBarShift(NULL, TimeFrame, Time[Bars - 1]); if(countedBars1 != bars1 - 1) { countedBars1 = bars1 - 1; ArrayInitialize(BufferK_Curr, EMPTY_VALUE); ArrayInitialize(BufferD_Curr, EMPTY_VALUE); if(TimeLabelName != "") if(ObjectFind(TimeLabelName) != -1) ObjectDelete(TimeLabelName); } if(start1 > limit1 && limit1 != -1) start1 = limit1; // Calcolo degli indicatori per ogni barra conforme al TimeFrame for(int i = start1; i >= 0; i--) { int shift1 = i; if(TimeFrame < Period()) shift1 = iBarShift(NULL, TimeFrame, Time[i]); int time1 = iTime(NULL, TimeFrame, shift1), shift2 = iBarShift(NULL, 0, time1); double stochK = iStochastic(NULL, TimeFrame, KPeriod, DPeriod, Slowing, MAMethod, PriceField, MODE_MAIN, shift1), stochD = iStochastic(NULL, TimeFrame, KPeriod, DPeriod, Slowing, MAMethod, PriceField, MODE_SIGNAL, shift1); // Aggiorna i buffer per le barre concluse if(shift1 >= 1) { BufferK[shift2] = stochK; BufferD[shift2] = stochD; } // Aggiorna i buffer per la barra corrente if((TimeFrame >= Period() && shift1 <= 1) || (TimeFrame < Period() && (shift1 == 0 || shift2 == 1))) { BufferK_Curr[shift2] = stochK; BufferD_Curr[shift2] = stochD; } // Interpolazione per le barre intermedie int n = 1; if(TimeFrame > Period()) { int shift2prev = iBarShift(NULL, 0, iTime(NULL, TimeFrame, shift1 + 1)); if(shift2prev != -1 && shift2prev != shift2) n = shift2prev - shift2; } // Applica l'interpolazione if(shift1 >= 1 && BufferK[shift2 + n] != EMPTY_VALUE && BufferK[shift2] != EMPTY_VALUE) { double factor = 1.0 / n; for(int k = 1; k < n; k++) { BufferK[shift2 + k] = k * factor * BufferK[shift2 + n] + (1.0 - k * factor) * BufferK[shift2]; BufferD[shift2 + k] = k * factor * BufferD[shift2 + n] + (1.0 - k * factor) * BufferD[shift2]; } } // Aggiornamento buffer e controllo delle frecce if(i > 0) // Non controlliamo l'ultima barra in fluttuazione { if(BufferK_Curr[shift2 + n] != EMPTY_VALUE && BufferK_Curr[shift2] != EMPTY_VALUE) { double factor = 1.0 / n; for(int k = 1; k < n; k++) { BufferK_Curr[shift2 + k] = k * factor * BufferK_Curr[shift2 + n] + (1.0 - k * factor) * BufferK_Curr[shift2]; BufferD_Curr[shift2 + k] = k * factor * BufferD_Curr[shift2 + n] + (1.0 - k * factor) * BufferD_Curr[shift2]; } } } } // Rilevamento degli incroci e disegno delle frecce sul grafico principale for(int j = Bars - countedBars1 - 1; j >= 0; j--) { // Salta la barra corrente in costruzione if(j == 0) continue; // Condizioni per disegnare una freccia verso l'alto if(BufferK_Curr[j] < BufferD_Curr[j] && BufferK_Curr[j + 1] > BufferD_Curr[j + 1]) { ArrowUpBuffer[j] = Low[j] - MathMax(MathAbs(Low[j] - High[j]), 4) * Point; ArrowDownBuffer[j] = EMPTY_VALUE; } // Condizioni per disegnare una freccia verso il basso else if(BufferK_Curr[j] > BufferD_Curr[j] && BufferK_Curr[j + 1] < BufferD_Curr[j + 1]) { ArrowDownBuffer[j] = High[j] + MathMax(MathAbs(Low[j] - High[j]), 4) * Point; ArrowUpBuffer[j] = EMPTY_VALUE; } else { // Non ci sono incroci ArrowUpBuffer[j] = EMPTY_VALUE; ArrowDownBuffer[j] = EMPTY_VALUE; } } return(0); }Il codice ora include il segmento finale per disegnare le frecce quando si verifica un incrocio tra le linee %K e %D. Ho utilizzato una funzione
MathMaxper la dimensione delle frecce per garantire che la distanza dalla barra sia proporzionale alla dimensione della barra stessa. Puoi regolare questo per far sì che le frecce siano visibili bene sul tuo grafico o cambiare il coefficiente numerico per allontanarle ulteriormente dalle barre. - User
ci sono errori: 'factor' - variable already defined #MTF Stochastic v2.1_2.mq4 229 24 'k' - variable already defined #MTF Stochastic v2.1_2.mq4 230 25 'j–' - undeclared identifier #MTF Stochastic v2.1_2.mq4 240 50
- Assistant
Chiedo scusa per l'errore. Parrebbe che all'interno del ciclo di interpolazione, la variabile
factorfosse stata ridefinita e la variabilekfosse stata usata senza dichiararla correttamente. Inoltre, c'è un errore di battitura inj–. Vediamo di correggere questi problemi.Ecco come dovrebbe essere scritto correttamente il ciclo all'interno di
start():// Dopo aver calcolato stochK e stochD nel ciclo... //---- apply interpolation for the number of intermediate bars (n) between two higher timeframe candles if (shift1 >= 1) { int shift2next = iBarShift(NULL, 0, iTime(NULL, TimeFrame, shift1 - 1)); int n = shift2next - shift2; // n is the number of lower timeframe bars within the current higher timeframe bar period double kFactor = (n > 1) ? 1.0 / n : 1; // Interpolate between shift2 and shift2next (the previous bar in the higher timeframe) for (int k = 1; k < n; k++) { if (BufferK[shift2 + k] == EMPTY_VALUE && BufferK[shift2] != EMPTY_VALUE && BufferK[shift2next] != EMPTY_VALUE) { BufferK[shift2 + k] = BufferK[shift2] + k * kFactor * (BufferK[shift2next] - BufferK[shift2]); BufferD[shift2 + k] = BufferD[shift2] + k * kFactor * (BufferD[shift2next] - BufferD[shift2]); } } } // Rilevamento degli incroci e disegno delle frecce... for (int j = Bars - countedBars1 - 1; j >= 1; j--) { // Start from the second bar to avoid accessing non-existent array elements // Process logic for drawing arrows... // Previous logic for arrows... }Questa versione modifica i nomi delle variabili per evitare conflitti ed elimina qualsiasi definizione duplicata. Inoltre, il ciclo per rilevare gli incroci e disegnare le frecce dovrebbe iniziare da 1 anziché 0 per evitare un errore quando si accede a
j + 1nell'array.Ricorda di definire correttamente i buffer per le frecce nella funzione
init()come segue:SetIndexBuffer(4, ArrowUpBuffer); SetIndexBuffer(5, ArrowDownBuffer); ArrayInitialize(ArrowUpBuffer, EMPTY_VALUE); // Initialize arrow buffers with EMPTY_VALUE ArrayInitialize(ArrowDownBuffer, EMPTY_VALUE);E per coerenza, assicurati che i buffer delle frecce siano dichiarati nella parte superiore del tuo file MQ4:
//---- indicator buffers double BufferK[], BufferD[], BufferK_Curr[], BufferD_Curr[], ArrowUpBuffer[], ArrowDownBuffer[];Dopo aver apportato queste modifiche, compila di nuovo l'indicatore in MT4 e testa per assicurarti che tutto funzioni come previsto.
- User
riscrivi tutto start
- Assistant
Vediamo una versione corretta della funzione
start()includendo le frecce e correggendo gli errori menzionati:int start() { // Conteggio delle barre già processate dal precedente update static int countedBars1 = 0; if(Bars <= countedBars1) return(0); int limit = Bars - countedBars1; for(int i = limit; i >= 0; i--) { // Calcolo degli indici per il timeframe corrente e quello superiore int shift1 = i; // Se il timeframe dell'indicatore è inferiore a quello del grafico corrente if(TimeFrame < Period()) shift1 = iBarShift(NULL, TimeFrame, Time[i]); // Calcola il valore dello Stocastico per l'indice calcolato double stochK = iStochastic(NULL, TimeFrame, KPeriod, DPeriod, Slowing, MAMethod, PriceField, MODE_MAIN, shift1); double stochD = iStochastic(NULL, TimeFrame, KPeriod, DPeriod, Slowing, MAMethod, PriceField, MODE_SIGNAL, shift1); // Assicuriamoci che lo shift sia valido int shift2 = iBarShift(NULL, 0, iTime(NULL, TimeFrame, shift1)); if(shift2 == -1) continue; BufferK[shift2] = stochK; BufferD[shift2] = stochD; // Interpolazione se necessario if(shift1 > 0) // Se non stiamo guardando l'ultima (corrente) barra { double prevStochK = iStochastic(NULL, TimeFrame, KPeriod, DPeriod, Slowing, MAMethod, PriceField, MODE_MAIN, shift1 - 1); double prevStochD = iStochastic(NULL, TimeFrame, KPeriod, DPeriod, Slowing, MAMethod, PriceField, MODE_SIGNAL, shift1 - 1); int shift2prev = iBarShift(NULL, 0, iTime(NULL, TimeFrame, shift1 - 1)); if(shift2prev != -1 && shift2prev > shift2) // Controllo degli indici { // Interpolazione lineare di valori tra shift2 e shift2prev int n = shift2prev - shift2; for(int k = 1; k < n; k++) { BufferK[shift2 + k] = stochK + ((prevStochK - stochK) / n) * k; BufferD[shift2 + k] = stochD + ((prevStochD - stochD) / n) * k; } } } // Non processare le frecce per la barra corrente (i==0) o per la prima barra storica if(i == limit || i == 0) continue; // Rileva gli incroci e imposta le frecce if(BufferK[shift2] < BufferD[shift2] && BufferK[shift2 - 1] > BufferD[shift2 - 1]) { // Incrocio verso l'alto (segnale di acquisto) ArrowUpBuffer[shift2] = Low[shift2] - (4 * Point); // Valore a cui posizionare la freccia verso l'alto ArrowDownBuffer[shift2] = EMPTY_VALUE; // Pulisce l'altro buffer per evitare sovrapposizioni di segnali } else if(BufferK[shift2] > BufferD[shift2] && BufferK[shift2 - 1] < BufferD[shift2 - 1]) { // Incrocio verso il basso (segnale di vendita) ArrowDownBuffer[shift2] = High[shift2] + (4 * Point); // Valore a cui posizionare la freccia verso il basso ArrowUpBuffer[shift2] = EMPTY_VALUE; // Pulisce l'altro buffer per evitare sovrapposizioni di segnali } else { // Nessun incrocio rilevato ArrowUpBuffer[shift2] = EMPTY_VALUE; ArrowDownBuffer[shift2] = EMPTY_VALUE; } } // Aggiorna il numero di barre contate dopo il calcolo countedBars1 = Bars; return(0); }Ecco cosa fa il codice:
- Imposta
countedBars1a zero se il numero di barre nel grafico è maggiore dicountedBars1. - Il ciclo
foritera attraverso le barre inverse a partire dall'ultima barra non contata. - Per ogni barra, calcola i valori stocastici per il time frame attuale.
- Esegue l'interpolazione se necessario per le barre intermedie.
- Esclude l'elaborazione delle frecce per l'ultima barra corrente e per la prima barra storica.
- Rileva gli incroci tra K e D, posizionando frecce verso l'alto o il basso secondo la condizione.
- Aggiorna la variabile
countedBars1al numero attuale di barre.
Fai attenzione nel codice MQL4 quando lavori con gli indici di array e con i calcoli che riguardano la sincronizzazione tra differenti timeframe di barre. Assicurati di testare l'indicatore in MT4 per confermare che funzioni come previsto.
- Imposta
- User
//+------------------------------------------------------------------+ //| MTF Stochastic.mq4 | //| 2007, Christof Risch (iya) | //| Stochastic indicator from any timeframe. | //+------------------------------------------------------------------+ // Change Log: // 2.1 2012 07 24 Modified to display only the Signal line (smoothed sma) // cr: 2012 07 20 Added NextHigherAuto to automatically seletc the next higher time frame // Added HidePctD to suppress the Slow line, prn
#property link "http://www.forexfactory.com/showthread.php?t=30109" #property indicator_separate_window #property indicator_buffers 4 #property indicator_color1 Green //C'255,255,255' // White // %K line #property indicator_color2 Red //Yellow // DimGray // %D line #property indicator_color3 Green // C'255,255,255' // White // %K line of the current candle #property indicator_color4 Red //Yellow // DimGray // %D line of the current candle #property indicator_level1 80 #property indicator_level2 20 #property indicator_level3 50 #property indicator_levelcolor DarkSlateGray #property indicator_maximum 100 #property indicator_minimum 0
//---- input parameters extern bool NextHigherAuto = true; extern bool HidePctK = false; extern bool HidePctD = false; extern int TimeFrame = 0, // {1=M1, 5=M5, 15=M15, ..., 1440=D1, 10080=W1, 43200=MN1} KPeriod = 11, DPeriod = 3, Slowing = 3, MAMethod = 0, // {0=SMA, 1=EMA, 2=SMMA, 3=LWMA} PriceField = 0; // {0=Hi/Low, 1=Close/Close} extern bool ShowClock = false; // display time to candle close countdown extern color ClockColor = Red;
//---- indicator buffers double BufferK[], BufferD[], BufferK_Curr[], BufferD_Curr[];
double ArrowUpBuffer[]; double ArrowDownBuffer[]; //---- string IndicatorName = "", TimeLabelName = "";
//+------------------------------------------------------------------+ //| Custom indicator initialization function | //+------------------------------------------------------------------+ int init() { if (TimeFrame == 0) TimeFrame = Period(); if (NextHigherAuto) TimeFrame = GetHigherTimeFrame(TimeFrame);
// name for DataWindow and indicator subwindow label switch(TimeFrame) { case PERIOD_M1: IndicatorName="Period M1"; break; case PERIOD_M5: IndicatorName="Period M5"; break; case PERIOD_M15: IndicatorName="Period M15"; break; case PERIOD_M30: IndicatorName="Period M30"; break; case PERIOD_H1: IndicatorName="Period H1"; break; case PERIOD_H4: IndicatorName="Period H4"; break; case PERIOD_D1: IndicatorName="Period D1"; break; case PERIOD_W1: IndicatorName="Period W1"; break; case PERIOD_MN1: IndicatorName="Period MN1"; break; default: {TimeFrame = Period(); init(); return(0);} } IndicatorName = IndicatorName + " Stoch(" + KPeriod + "," + DPeriod + "," + Slowing + ")"; IndicatorShortName(IndicatorName); IndicatorDigits(1); string TimeFrameStr = TF2Str(TimeFrame); //---- set indicator buffers SetIndexBuffer(0, BufferK); ArraySetAsSeries(BufferK, true); SetIndexBuffer(1, BufferD); ArraySetAsSeries(BufferD, true); SetIndexBuffer(2, BufferK_Curr); ArraySetAsSeries(BufferK_Curr, true); SetIndexBuffer(3, BufferD_Curr); ArraySetAsSeries(BufferD_Curr, true); SetIndexBuffer(4, ArrowUpBuffer); ArraySetAsSeries(ArrowUpBuffer, true); SetIndexBuffer(5, ArrowDownBuffer); ArraySetAsSeries(ArrowDownBuffer, true); //---- set index draw begin and styles according to HidePctK and HidePctD if (!HidePctK) { SetIndexStyle(0, DRAW_LINE, EMPTY, 1); SetIndexLabel(0, TimeFrameStr + " %K line"); SetIndexStyle(2, DRAW_LINE, EMPTY, 1); SetIndexLabel(2, TimeFrameStr + " %K CurrBar"); } else { SetIndexStyle(0, DRAW_NONE); SetIndexLabel(0, NULL); SetIndexStyle(2, DRAW_NONE); SetIndexLabel(2, NULL); } if (!HidePctD) { SetIndexStyle(1, DRAW_LINE, EMPTY, 1); SetIndexLabel(1, TimeFrameStr + " %D Signal"); SetIndexStyle(3, DRAW_LINE, EMPTY, 1); SetIndexLabel(3, TimeFrameStr + " %D CurrBar"); } else { SetIndexStyle(1, DRAW_NONE); SetIndexLabel(1, NULL); SetIndexStyle(3, DRAW_NONE); SetIndexLabel(3, NULL); } //---- arrows settings SetIndexArrow(4, SYMBOL_ARROWUP); SetIndexStyle(4, DRAW_ARROW); SetIndexLabel(4, "Stochastic Arrow Up"); SetIndexArrow(5, SYMBOL_ARROWDOWN); SetIndexStyle(5, DRAW_ARROW); SetIndexLabel(5, "Stochastic Arrow Down"); return(INIT_SUCCEEDED);} //+------------------------------------------------------------------+ int deinit() { if(TimeLabelName!="") if(ObjectFind (TimeLabelName) != -1) ObjectDelete(TimeLabelName); }
//+------------------------------------------------------------------+ //| MTF Stochastic | //+------------------------------------------------------------------+ int start() { // Conteggio delle barre già processate dal precedente update static int countedBars1 = 0;
if(Bars <= countedBars1) return(0); int limit = Bars - countedBars1; for(int i = limit; i >= 0; i--) { // Calcolo degli indici per il timeframe corrente e quello superiore int shift1 = i; // Se il timeframe dell’indicatore è inferiore a quello del grafico corrente if(TimeFrame < Period()) shift1 = iBarShift(NULL, TimeFrame, Time[i]); // Calcola il valore dello Stocastico per l’indice calcolato double stochK = iStochastic(NULL, TimeFrame, KPeriod, DPeriod, Slowing, MAMethod, PriceField, MODE_MAIN, shift1); double stochD = iStochastic(NULL, TimeFrame, KPeriod, DPeriod, Slowing, MAMethod, PriceField, MODE_SIGNAL, shift1); // Assicuriamoci che lo shift sia valido int shift2 = iBarShift(NULL, 0, iTime(NULL, TimeFrame, shift1)); if(shift2 == -1) continue; BufferK[shift2] = stochK; BufferD[shift2] = stochD; // Interpolazione se necessario if(shift1 > 0) // Se non stiamo guardando l’ultima (corrente) barra { double prevStochK = iStochastic(NULL, TimeFrame, KPeriod, DPeriod, Slowing, MAMethod, PriceField, MODE_MAIN, shift1 - 1); double prevStochD = iStochastic(NULL, TimeFrame, KPeriod, DPeriod, Slowing, MAMethod, PriceField, MODE_SIGNAL, shift1 - 1); int shift2prev = iBarShift(NULL, 0, iTime(NULL, TimeFrame, shift1 - 1)); if(shift2prev != -1 && shift2prev > shift2) // Controllo degli indici { // Interpolazione lineare di valori tra shift2 e shift2prev int n = shift2prev - shift2; for(int k = 1; k < n; k++) { BufferK[shift2 + k] = stochK + ((prevStochK - stochK) / n) * k; BufferD[shift2 + k] = stochD + ((prevStochD - stochD) / n) * k; } } } // Non processare le frecce per la barra corrente (i==0) o per la prima barra storica if(i == limit || i == 0) continue; // Rileva gli incroci e imposta le frecce if(BufferK[shift2] < BufferD[shift2] && BufferK[shift2 - 1] > BufferD[shift2 - 1]) { // Incrocio verso l’alto (segnale di acquisto) ArrowUpBuffer[shift2] = Low[shift2] - (4 * Point); // Valore a cui posizionare la freccia verso l’alto ArrowDownBuffer[shift2] = EMPTY_VALUE; // Pulisce l’altro buffer per evitare sovrapposizioni di segnali } else if(BufferK[shift2] > BufferD[shift2] && BufferK[shift2 - 1] < BufferD[shift2 - 1]) { // Incrocio verso il basso (segnale di vendita) ArrowDownBuffer[shift2] = High[shift2] + (4 * Point); // Valore a cui posizionare la freccia verso il basso ArrowUpBuffer[shift2] = EMPTY_VALUE; // Pulisce l’altro buffer per evitare sovrapposizioni di segnali } else { // Nessun incrocio rilevato ArrowUpBuffer[shift2] = EMPTY_VALUE; ArrowDownBuffer[shift2] = EMPTY_VALUE; } } // Aggiorna il numero di barre contate dopo il calcolo countedBars1 = Bars; return(0);}
string TF2Str(int iPeriod) { switch(iPeriod) { case PERIOD_M1: return("M1"); case PERIOD_M5: return("M5"); case PERIOD_M15: return("M15"); case PERIOD_M30: return("M30"); case PERIOD_H1: return("H1"); case PERIOD_H4: return("H4"); case PERIOD_D1: return("D1"); case PERIOD_W1: return("W1"); case PERIOD_MN1: return("MN1"); default: return("M"+iPeriod); } return(0); }
int GetHigherTimeFrame(int CurrentPeriod ) { if ( CurrentPeriod == 0 ) CurrentPeriod = Period(); if( CurrentPeriod == 1 ) { return(5); } else if( CurrentPeriod == 5 ) { return(15); } else if( CurrentPeriod == 15 ) { return(30); } else if( CurrentPeriod == 30 ) { return(60); } else if( CurrentPeriod == 60 ) { return(240); } else if( CurrentPeriod == 240 ) { return(1440); } else if( CurrentPeriod == 1440 ) { return(10080); } else if( CurrentPeriod == 10080 ) { return(43200); } else if( CurrentPeriod == 43200 ) { return(43200); } } // int GetHigherTimeFrame()
continua a non esserci nulla, ne lo stocastico ne le frecce
- Assistant
Dall'analisi del tuo codice completo, sembra che ci siano alcune discordanze tra la definizione e l'uso dei buffer. Innanzitutto, nell'intestazione del tuo codice, definisci 6 buffer tramite la direttiva
#property indicator_buffers 4, ma effettivamente usi 6 buffer, poiché hai anche aggiuntoArrowUpBuffer[]eArrowDownBuffer[].Per risolvere questo, la direttiva
#property indicator_buffers 4dovrebbe essere cambiata a#property indicator_buffers 6per accomodare tutti i 6 buffer che usi:#property indicator_buffers 6Successivamente, ci sono alcuni errori che potrebbero influire sul funzionamento dell'indicatore, incluso l'uso di due buffer aggiuntivi che non sono stati definiti in precedenza. Quindi, nella funzione
init()dovresti inizializzare questi buffer aggiuntivi come array di serie:SetIndexBuffer(4, ArrowUpBuffer); ArraySetAsSeries(ArrowUpBuffer, true); SetIndexBuffer(5, ArrowDownBuffer); ArraySetAsSeries(ArrowDownBuffer, true);Inoltre, devi definire gli stili e i segni delle frecce sempre nella funzione
init():SetIndexStyle(4, DRAW_ARROW); SetIndexArrow(4, SYMBOL_ARROWUP); // or the code number for the arrow symbol SetIndexLabel(4, "Up Arrow"); SetIndexStyle(5, DRAW_ARROW); SetIndexArrow(5, SYMBOL_ARROWDOWN); // or the code number for the arrow symbol SetIndexLabel(5, "Down Arrow");Una volta che hai aggiornato la direttiva
#propertye i buffer nella funzioneinit(), assicurati che la funzionestart()calcoli e utilizzi correttamente tutti i buffer, inclusi quelli per le frecce.Quindi, riprova a compilare l'indicatore e a caricarlo su un grafico in MT4. Se i calcoli degli stocastici e le condizioni per le frecce sono corretti, e se hai inserito correttamente gli indici dei buffer, dovresti vedere sia le linee dello stocastico che le frecce disegnate sul grafico.
Se continui a non vedere risultati, potrebbe essere utile ripassare la logica di calcolo delle frecce nella funzione
start()e assicurarti che le condizioni di crossover siano soddisfatte durante i periodi di test. Di seguito è riportato un esempio di come potresti implementare il rilevamento degli incroci e il posizionamento delle frecce nella funzionestart():int start() { // ... (il resto della funzione start come nel tuo ultimo codice) // Il ciclo finale per il rilevamento degli incroci e il disegno delle frecce: for(int i = Bars - countedBars1 - 1; i >= 1; i--) { // Bisogna iniziare da 1 (seconda barra dall'ultima) if(BufferK_Curr[i] == EMPTY_VALUE || BufferD_Curr[i] == EMPTY_VALUE) continue; double currentK = BufferK_Curr[i]; double currentD = BufferD_Curr[i]; double previousK = BufferK_Curr[i + 1]; double previousD = BufferD_Curr[i + 1]; // Incrocio dal basso verso l’alto if(previousK < previousD && currentK > currentD) { ArrowUpBuffer[i] = Low[i] - (4 * Point); // Imposta qui il valore in base allo spazio desiderato tra la freccia e il prezzo ArrowDownBuffer[i] = EMPTY_VALUE; } // Incrocio dall’alto verso il basso else if(previousK > previousD && currentK < currentD) { ArrowDownBuffer[i] = High[i] + (4 * Point); // Imposta qui il valore in base allo spazio desiderato tra la freccia e il prezzo ArrowUpBuffer[i] = EMPTY_VALUE; } else { ArrowUpBuffer[i] = EMPTY_VALUE; ArrowDownBuffer[i] = EMPTY_VALUE; } } return(0); }Verifica che le direttive
#property, la logica di calcolo e la logica di rilevamento degli incroci abbiano tutte le configurazioni corrette, come mostrato sopra.