Toute question de débutant, afin de ne pas encombrer le forum. Professionnels, ne passez pas à côté. Nulle part sans toi - 6. - page 539
Vous manquez des opportunités de trading :
- Applications de trading gratuites
- Plus de 8 000 signaux à copier
- Actualités économiques pour explorer les marchés financiers
Inscription
Se connecter
Vous acceptez la politique du site Web et les conditions d'utilisation
Si vous n'avez pas de compte, veuillez vous inscrire
Merci ! Cela a fonctionné, j'étais heureux comme un enfant, mais le conseiller a cessé d'afficher "nouveau". Pouvez-vous me dire où j'ai fait fausse route ?
Huh, j'ai trouvé l'erreur, pas là où je cherchais à l'origine. Je ne peux pas faire face à la prochaine tâche moi-même.
Veuillez m'indiquer comment définir la plage de déviation - distance du prix par rapport à la MA.
Voici la partie entrée
Huh, j'ai trouvé l'erreur, pas là où je cherchais à l'origine. Je ne peux pas m'occuper seul de la prochaine tâche.
Pouvez-vous me dire comment définir la plage de déviation - distance du prix par rapport à la MA.
Voici la partie entrée
Et par conséquent, la condition
Nous devons changer les données brutes dans le conseiller correctement à (1 achat, -1 vente)
//+------------------------------------------------------------------+
//| SimpleBars_rob.mq4 |//| Copyright © 2010, ENSED Team |
//| http://www.ensed.org |
//+------------------------------------------------------------------+
#property copyright "Copyright © 2010, ENSED Team"
#lien de propriété "http://www.ensed.org"
extern int SL = 50 ; // valeur du stop loss (en pips)
TP = 150 ; // Valeur du Take Profit (en points)
extern double Lots = 0.1 ; // lot de travail (micro lots - 0.01, mini lots - 0.1, lots normaux - 1.0)
extern string Order_Comment = "robot" ; // commentaire qui sera utilisé pour passer des commandes
extern int Slipage = 5 ; // niveau de glissement maximal autorisé (en points)
extern int int Magic_Number = 777 ; // nombre magique de commandes pour le robot (pour distinguer les transactions "amicales")
extern bool Play_Sound = false ; // lecture du son à l'ouverture : true - autorisé, false - interdit
//--------------------------------------------------------------------------------------------------------------------+
//+ configuration des délais et des paramètres de l'indicateur SimpleBars.
extern int period = 6 ;
extern bool useClose = true ;
extern int width = 3 ;
//+ ajustement des délais et des paramètres de l'indicateur SimpleBars | |.
//--------------------------------------------------------------------------------------------------------------------+
//+-------------------------------------------------------------------------------------------------------------------+
//+ trailing stop |
extern bool UseTrailing = true ; // activation/désactivation du trailing stop
extern int TrailingStop = 50 ; // taille fixe du trailing stop (en pips)
extern int TrailingStep = 1 ; // pas de trailing stop (en points)
//+ trailing stop
//+-------------------------------------------------------------------------------------------------------------------+
//+-------------------------------------------------------------------------------------------------------------------+
//| La fonction est exécutée à l'initialisation du programme.
void init() {
if(GlobalVariableCheck("this_bar "+Symbol()+Period()))
GlobalVariableDel("this_bar "+Symbol()+Period()) ;
retour ;
}
//| fonction, qui est exécutée pendant l'initialisation du programme.
//+-------------------------------------------------------------------------------------------------------------------+
//+-------------------------------------------------------------------------------------------------------------------+
//| La fonction est exécutée à la désinitialisation du programme.
void deinit() {
if(GlobalVariableCheck("this_bar "+Symbol()+Period()))
GlobalVariableDel("this_bar "+Symbol()+Period()) ;
retour ;
}
//| fonction, qui est exécutée lors de la désinitialisation du programme.
//+-------------------------------------------------------------------------------------------------------------------+
//+-------------------------------------------------------------------------------------------------------------------+
//| fonction de recherche d'un signal de négociation |
int fsignals() {
double signal = iCustom(NULL, 0, "SimpleBars", period, 0, 1, 4, 0) ;
return(0) ; // signal d'ouverture d'un Achat
return(1) ; //ouverture du signal Sell
return(-1) ; // pas de signal
} //fin int fsignals()
//| fonction de recherche d'un signal de négociation
//+-------------------------------------------------------------------------------------------------------------------+
//+-------------------------------------------------------------------------------------------------------------------+
//| fonction de suivi du travail du robot sur la barre donnée
bool this_bar() {
si(
(!GlobalVariableCheck("this_bar "+Symbol()+Period()))
|| (GlobalVariableGet("this_bar "+Symbol()+Period()!=Time[0])
) {
GlobalVariableSet("this_bar "+Symbol()+Period(),Time[0]) ;
retour (faux) ;
} else {
retour (vrai) ;
} //finir si (. (!GlobalVariableCheck("this_bar "+Symbol()+Period()))
} //fin bool this_bar()
//| fonction de suivi du fait que le robot travaille sur la barre donnée
//+-------------------------------------------------------------------------------------------------------------------+
//+-------------------------------------------------------------------------------------------------------------------+
//| fonction de recherche des commandes de ce type |
bool find_orders(int magic=-1, int type=-1, string symb="NULL") {
/* renvoie vrai si au moins un ordre du type donné avec le numéro magique donné est trouvé par le symbole donné */.
for (int i=OrdersTotal()-1 ; i>=0 ; i--) {
if(!OrderSelect(i,SELECT_BY_POS,MODE_TRADES)) break ;
si(((OrderType()==type) || (type==-1))
&& ((OrderMagicNumber()==magic) || (magic==-1))
&& ((OrderSymbol()==Symbol() || (symb=="NONE"))))) {
//si un ordre est trouvé, return(true) et sortie de la boucle
retour (vrai) ;
pause ;
} //end if((OrderType()==type) && (OrderMagicNumber()==magic) && (OrderSymbol()==Symbol())
} //fin pour (int i2=OrdersTotal()-1 ; i2>=0 ; i2--)
return(false) ; //retourne false
} //fin bool find_orders(int magic, int type)
//| fonction de recherche des commandes du type donné |
//+-------------------------------------------------------------------------------------------------------------------+
//+-------------------------------------------------------------------------------------------------------------------+
//| fonction de calcul de la valeur du Stop Loss pour les ordres ||.
double sl(int sl_value, int type, double price=0.0, string symb="NONE", int rmode=1) {
//type=0 -> achats sur le marché
//type=1 -> ventes sur le marché
if(symb=="NONE") symb=Symbol() ;
if(type==0) price=NormalizeDouble(MarketInfo(symb,MODE_ASK),MarketInfo(symb,MODE_DIGITS))
if(type==1) price=NormalizeDouble(MarketInfo(symb,MODE_BID),MarketInfo(symb,MODE_DIGITS)) ;
si(sl_value<=0) return(0) ;
si(rmode==1) {
if((type==0) || (type==2) || (type==4)) return(MarketInfo(symb,MODE_ASK)-sl_value*MarketInfo(symb,MODE_POINT)) ; //pour les achats
if((type==1) || (type==3) || (type==5)) return(MarketInfo(symb,MODE_BID)+sl_value*MarketInfo(symb,MODE_POINT)) ; //pour la vente
}
si(rmode==2) {
if((type==0) || (type==2) || (type==4)) return(MarketInfo(symb,MODE_BID)-sl_value*MarketInfo(symb,MODE_POINT)) ; //pour l'achat
if((type==1) || (type==3) || (type==5)) return(MarketInfo(symb,MODE_ASK)+sl_value*MarketInfo(symb,MODE_POINT)) ; //pour la vente
}
} //fin double sl(int sl_value, int type, double price=0.0, string symb="NONE", int rmode=1)
//| fonction pour le calcul de la valeur du Stop Loss pour les ordres | |
//+-------------------------------------------------------------------------------------------------------------------+
//+-------------------------------------------------------------------------------------------------------------------+
//| fonction de calcul des valeurs de Take Profit pour les ordres
double tp(int tp_value, int type, double price=0.0, string symb="NONE") {
//type=0 -> achat sur le marché
//type=1 -> ventes sur le marché
if(symb=="NONE") symb=Symbol() ;
if(type==0) price=NormalizeDouble(MarketInfo(symb,MODE_ASK),MarketInfo(symb,MODE_DIGITS) ;
if(type==1) price=NormalizeDouble(MarketInfo(symb,MODE_BID),MarketInfo(symb,MODE_DIGITS)) ;
si(tp_value<=0) return(0) ;
if((type==0) || (type==2) || (type==4)) return(price+tp_value*MarketInfo(symb,MODE_POINT)) ; //pour les achats
if((type==1) || (type==3) || (type==5)) return(MarketInfo(symb,MODE_BID)-tp_value*MarketInfo(symb,MODE_POINT)) ; //pour les ventes
} //fin double tp(int tp_value, int type, double price=0.0, string symb="NONE")
//| Fonction de calcul de la valeur du Take Profit pour les ordres.
//+-------------------------------------------------------------------------------------------------------------------+
//+-------------------------------------------------------------------------------------------------------------------+
//| fonction d'ouverture des commandes
void open_positions(int signal, double lot, double prix=0.0, string symb="NONE") {
//signal=0 -> signal pour ouvrir un achat
//signal=1 -> signal pour ouvrir la vente
/* extern */ int Count_Of_Trade_Try=5, Pause_Of_Trade_Try=5 ;
int i = 0 ; //variable pour le compteur de la boucle
int err = 0 ;
if(symb=="NONE") symb=Symbol() ;
si(signal==0)
price=NormalizeDouble(MarketInfo(symb,MODE_ASK),MarketInfo(symb,MODE_DIGITS)) ; //prix d'ouverture à l'achat
si(signal==1)
price=NormalizeDouble(MarketInfo(symb,MODE_BID),MarketInfo(symb,MODE_DIGITS)) ; //prix d'ouverture à la vente
while(i<=Count_Of_Trade_Try) {
La //fonction d'ouverture de l'ordre (intégrée). Pour faciliter la perception, les paramètres sont placés sur des lignes différentes :
int ticket = OrderSend(Symbole(), //symbole
signal, //type de commande
lot, //volume
prix, //prix d'ouverture
Slipage, //niveau de requote autorisé
sl(SL,signal), // valeur du Stop Loss
tp(TP,signal), //prendre la valeur du profit
Order_Comment, //commentaire de l'ordre
Magic_Number, //nombre magique
0, //temps d'expiration (utilisé pour les ordres en attente)
CLR_NONE) ; //couleur de la flèche affichée sur le graphique (CLR_NONE - la flèche n'est pas dessinée)
if(ticket!=-1) //si l'ouverture a réussi, dessiner un objet graphique et sortir de la boucle
pause ;
err=GetLastError() ;
if(err!=0) Print("Erreur : "+Market_Err_To_Str(err)) ;
i++ ;
Sleep(Pause_Of_Trade_Try*1000) ; //en cas d'erreur, pause avant réessai
} //finir alors que(i<=count)
} //fin void open_positions(int signal, double lot, double prix=0.0, string symb="NONE")
//| fonction d'ouverture des ordres |
//+-------------------------------------------------------------------------------------------------------------------+
//+-------------------------------------------------------------------------------------------------------+
//| fonction de décodage des codes d'erreur |
string Market_Err_To_Str(int err) {
/* la fonction ne couvre que les codes d'erreur des opérations commerciales */
switch(err) {
cas(0) : return("Aucune erreur") ;
case(1) : return("Aucune erreur, mais le résultat est inconnu") ;
cas(2) : return("Erreur générale") ;
cas(3) : return("Paramètres incorrects") ;
case(4) : return("Le serveur commercial est occupé") ;
case(5) : return("Ancienne version du terminal client") ;
case(6) : return("Pas de connexion au serveur commercial") ;
case(7) : return("Pas assez de droits") ;
case(8) : return("Demandes trop fréquentes") ;
case(9) : return("Une opération non valide perturbe le fonctionnement du serveur") ;
case(64) : return("Compte bloqué") ;
case(65) : return("Numéro de compte incorrect") ;
case(128) : return("Le délai de la transaction a expiré") ;
case(129) : return("Prix incorrect") ;
case(130) : return("Arrêts incorrects") ;
case(131) : return("Volume incorrect") ;
case(132) : return("Le marché est fermé") ;
case(133) : return("Trading interdit") ;
case(134) : return("Pas assez d'argent pour exécuter la transaction") ;
case(135) : return("Le prix a changé") ;
case(136) : return("Aucun prix") ;
case(137) : return("Le courtier est occupé") ;
case(138) : return("Nouveaux prix") ;
case(139) : return("La commande est bloquée et est déjà en cours de traitement") ;
case(140) : return("Achat autorisé uniquement") ;
case(141) : return("Trop de demandes") ;
case(145) : return("La modification n'est pas autorisée, car l'ordre est trop proche du marché") ;
case(146) : return("Le sous-système de négociation est occupé") ;
case(147) : return("L'utilisation de la date d'expiration est interdite par le courtier") ;
case(148) : return("Le nombre d'ordres ouverts et en attente a atteint la limite fixée par le courtier ;)
case(149) : return("Tentative d'ouverture d'une position opposée à une position existante si la couverture est interdite") ;
case(150) : return("Tentative de fermeture d'une position sur un symbole en violation de la règle FIFO") ;
par défaut : return("") ;
} //fin switch(err)
} //fin de la chaîne Err_To_Str(int err)
//| fonction pour décoder les codes d'erreur |
//+-------------------------------------------------------------------------------------------------------+
//+-------------------------------------------------------------------------------------------------------+
//| Opérations de clôture de la transaction ||
//+----------------------------------------------------------------------------------------------------+
//| fonction de clôture d'une commande par son numéro (ticket) ||.
bool close_by_ticket(int c_ticket, int slipage) {
/*
fonction de clôture d'une transaction par son numéro (ticket).
Lors de la clôture d'un ordre au marché, le niveau de slippage maximum autorisé est pris en compte (slipage).
*/
/* extern */ int Count_Of_Trade_Try=5, Pause_Of_Trade_Try=5 ;
int i = 0 ; //variable pour le compteur de la boucle
int err = 0 ;
bool ticket = false ; //variable pour la fermeture (non)réussie d'une transaction.
double price = 0.0 ; //prix de la transaction à clôturer (pour les ordres au marché)
if(OrderSelect(c_ticket,SELECT_BY_TICKET,MODE_TRADES)) { //sélectionner l'ordre par ticket
if(OrderType()==OP_BUY) price = NormalizeDouble(Bid,Digits) ; //prix à l'achat
if(OrderType()==OP_SELL) price = NormalizeDouble(Ask,Digits) ; //prix de vente
for(i=0;i<=Count_Of_Trade_Try;i++) {
if(OrderType()<=1) //si l'ordre est un ordre au marché, fermez-le, si c'est un ordre en attente, supprimez-le.
ticket=OrderClose(OrderTicket(),OrderLots(),price,slipage,CLR_NONE) ;
sinon
ticket=OrderDelete(OrderTicket()) ;
if(ticket) { //si la fermeture ou la suppression a réussi, renvoyer vrai et sortir de la boucle
retour (vrai) ;
pause ;
} //finir if(ticket)
err=GetLastError() ;
if(err!=0) Print("Erreur : "+Market_Err_To_Str(err)) ;
Sleep(Pause_Of_Trade_Try*1000) ; //en cas d'erreur, faire une pause avant de réessayer
} //fin pour(i=0;i<=Count_Of_Trade_Try;i++)
} //finir if(OrderSelect(c_ticket,SELECT_BY_TICKET,MODE_TRADES))
return(false) ; //retourne false
} //fin bool close_by_ticket(int c_ticket)
//| fonction de clôture d'une commande par son numéro (ticket) ||.
//+----------------------------------------------------------------------------------------------------+
bool cbm(int magic, int slipage, int type) {
/*
Fermer par magie (fermer tous les ordres du type donné avec le MagicNumber donné)
Le glissement maximal autorisé est pris en compte.
La fonction close_by_ticket est utilisée.
*/
int n = 0 ;
while (find_orders(magic, type))
for (int i2=OrdersTotal()-1 ; i2>=0 ; i2--) {
if (!OrderSelect(i2,SELECT_BY_POS,MODE_TRADES)) break ;
si ((OrderType()==type) && (OrderMagicNumber()==magic)) {
close_by_ticket(OrderTicket(), slip ;)
n++ ;
} //fin si (((OrderType()==OP_BUY) || (OrderType()==OP_SELL)) && (OrderMagicNumber()==magique))
} //fin pour (int i2=OrdersTotal()-1 ; i2>=0 ; i2--)
si(n>0)
retour (vrai) ;
retour (faux) ;
} //fin bool cbm(int magic, int slipage, int type)
//| Opérations de clôture du commerce |
//+-------------------------------------------------------------------------------------------------------+
//+-------------------------------------------------------------------------------------------------------------------+
//| trailing stop loss |
void T_SL() {
if(!UseTrailing) return ;
int i = 0 ;
for(i=0 ; i<OrdersTotal() ; i++) {
si( !(OrderSelect(i, SELECT_BY_POS, MODE_TRADES))) continuer ;
if(OrderSymbol() != Symbol() || OrderMagicNumber()!=Magic_Number) continuer ;
si(OrderType()==OP_BUY) {
if(NormalizeDouble(Bid-OrderOpenPrice(),Digits)>NormalizeDouble(TrailingStop*Point,Digits)) {
if(NormalizeDouble(OrderStopLoss(),Digits)<NormalizeDouble(Bid-(TrailingStop+TrailingStep-1)*Point,Digits))
OrderModify(OrderTicket(), OrderOpenPrice(), NormalizeDouble(Bid-TrailingStop*Point,Digits), OrderTakeProfit(), 0, CLR_NONE)
} //finir si(NormalizeDouble(Bid-OrderOpenPrice(),Digits)>NormalizeDouble(TrailingStop*Point,Digits))
} //fin si(OrderType()==OP_BUY)
si(OrderType()==OP_SELL) {
if(NormalizeDouble(OrderOpenPrice()-Ask,Digits)>NormalizeDouble(TrailingStop*Point,Digits)) {
if(NormalizeDouble(OrderStopLoss(),Digits)>NormalizeDouble(Ask+(TrailingStop+TrailingStep-1)*Point,Digits))
OrderModify(OrderTicket(), OrderOpenPrice(), NormalizeDouble(Ask+TrailingStop*Point,Digits), OrderTakeProfit(), 0, CLR_NONE)
} //fin si(NormalizeDouble(OrderOpenPrice()-Ask,Digits)>NormalizeDouble(TrailingStop*Point,Digits))
} //fin si(OrderType()==OP_SELL)
} //fin pour(i=0 ; i<OrdersTotal() ; i++)
} //fin void T_SL()
//| trailing stop loss |
//+-------------------------------------------------------------------------------------------------------------------+
//+-------------------------------------------------------------------------------------------------------------------+
//| fonction principale |
void start() {
int sig = fsignals() ;
if(!find_orders(Magic_Number)) {
si((sig!=-1)) {
if(!this_bar()) {
open_positions(sig, Lots) ;
if(Play_Sound)
PlaySound("alert.wav") ;
}
} //fin si((sig!=-1) && (!this_bar())
} else {
si(sig==0) {
if(cbm(Magic_Number, Slipage, 1)) {
open_positions(sig, Lots) ;
if(Play_Sound)
PlaySound("alert.wav") ;
} //finish if(cbm(Magic_Number, Slipage, 1))
} //fin si(sig==0)
if(sig==1) {
if(cbm(Magic_Number, Slipage, 0)) {
open_positions(sig, Lots) ;
if(Play_Sound)
PlaySound("alert.wav") ;
} //finir si(cbm(Magic_Number, Slipage, 0))
} //fin si(sig==1)
T_SL() ;
} //finir si(!find_orders(Magic_Number) (autre)
retour ;
}
//| fonction principale |
//+-------------------------------------------------------------------------------------------------------------------+
Bonjour les connaisseurs. Aide - ne fonctionne pas. Je pense que j'ai été confus par l'initialisation des variables . Ma tête tourne, mais je ne trouve aucune erreur.
Au lieu d'ouvrir des positions, l'EA doit dessiner des flèches au prix Klose (0), et au lieu de fermer - une croix et imprimer les données ( fExpiration_func(Expiration), fop_time, cl_time, fop_price, cl_price, ftype) dans une nouvelle ligne.
Ici, le stochastique n'est pris qu'à titre d'exemple.
La question est alors de savoir comment renvoyer les deux valeurs. J'ai essayé ceci, mais les erreurs
La question est alors de savoir comment renvoyer les deux valeurs. J'ai essayé ceci, mais les erreurs
La question est alors de savoir comment renvoyer les deux valeurs. J'ai essayé ceci, mais les erreurs
Avez-vous essayé d'utiliser des variables ? Peut-être que ça aidera.
Aidez-nous si vous le voulez bien
pour apprendre à un conseiller expert à négocier en fonction de l'indicateur
BS_Living Now ver #1.mq4 https://www.mql5.com/ru/code/11014#50910
UP= iCustom(Symbol(),NULL, "Now",BQuant,0,0) ;
DOW= iCustom(Symbol(),NULL, "Now",BQuant,1,0) ;
if(DOW){OrderSend(Symbol(), OP_SELL, Lot, Bid, Slip, 0, 0, "Forex-Robots.ru SELL", Magic, 0,Red);}
if(UP ){OrderSend(Symbol(), OP_BUY, Lot, Ask, Slip, 0, 0, "Forex-Robots.ru BUY", Magic, 0,Blue);}
Commentaire
(
"Profit" : ", UP,
"Profit" : ", DOW
) ;
J'ai essayé de lire les valeurs dans le commentaire mais elles sont toujours statiques.
Avez-vous essayé d'utiliser des variables ? Cela pourrait aider.
Merci, ça marche.
Aidez-nous si vous le voulez bien
pour apprendre à un conseiller expert à négocier en fonction de l'indicateur
BS_Living Now ver #1.mq4 https://www.mql5.com/ru/code/11014#50910