¡Pide! - página 117

Nuevo comentario
 

int inicio(){

if(TimeCurrent()>D'2008.07.01 12:00:00'){Comment("EXPIRADO"); return(0);}

...

return(0);

}

amatrader:
Por favor, alguien puede decirme si es posible tener un límite de fecha en un EA, lo que quiero decir es que puedo establecer una fecha de caducidad en un EA que una vez que llega a la fecha establecida simplemente deja de operar.

Probablemente diría algo así:-

comprueba la fecha, si la fecha es igual o mayor que (set date) no hace nada.

Esa es la versión inglesa, necesito la versión MQL4...lol

Gracias si alguien puede ayudar.
 
amatrader:
Por favor, alguien puede decirme si es posible tener un límite de fecha en un EA, lo que quiero decir es que puedo establecer una fecha de caducidad en un EA que una vez que llega a la fecha establecida simplemente deja de operar.

Probablemente diría algo así:-

comprobar la fecha, si la fecha es igual o mayor que (fecha establecida) no hacer nada.

Esa es la versión inglesa, necesito la versión MQL4...lol

Gracias si alguien puede ayudar.

Mira este hilo https://www.mql5.com/en/forum/174194

 

Gracias señor... Muy apreciado.

 

Alto Bajo Semanal.

¿Puede alguien publicar un indicador semanal High Low como el adjunto para el diario?

O tal vez cambiar el adjunto a un semanal para mí por favor.

Gracias de antemano.

Archivos adjuntos:
daily_high_low_.mq4  4 kb
 

Utilice este indicador https://www.mql5.com/en/forum/173574/page32 (es diario, semanal y mensual).

O este otro https://www.mql5.com/en/forum/177792

O este otro https://www.mql5.com/en/forum/178698

 

Hola a todos

Este es el ea que estoy usando. Puede alguien decirme que cambiar para tener un BUY-STOP y un SELL_Stop tomados al mismo tiempo. De la forma en que está ahora, o se activa un buy-stop o un sell-stop. Me gustaría tener ambos. En segundo lugar, qué debo hacer para limitar el número de órdenes por cada vela.

Gracias a todos por adelantado.

aquí está el código:

void start() {

//---- comprueba el historial y las operaciones

if(Bars<100 || IsTradeAllowed()==false) return;

co=CalculateCurrentOrders(Symbol());

CheckForSignals();

if (co>0) CheckForClose();

CheckForOpen();

co=CalcularOrdenesActualess(Símbolo());

si (mkt>0) {

BreakEvenStop(BreakEven,0);

double pcnt =( (CuentaPatrimonio()-CuentaSaldo()) / AccountBalance())*100;

Print("Patrimonio de la cuenta = ",Patrimonio de la cuenta());

Print("Saldo de la cuenta = ",Saldo de la cuenta());

if(pcnt>Porcentaje de ganancia de la cuenta)

{

int total = OrdersTotal();

for(int i=total-1;i>=0;i--)

{

OrderSelect(i, SELECT_BY_POS);

int tipo = OrderType();

bool resultado = false;

switch(tipo)

{

/Cierre de las posiciones largas abiertas

case OP_BUY : result = OrderClose( OrderTicket(), OrderLots(), MarketInfo(OrderSymbol(), MODE_BID), 5, Red );

romper;

/Cierre de las posiciones cortas abiertas

case OP_SELL : result = OrderClose( OrderTicket(), OrderLots(), MarketInfo(OrderSymbol(), MODE_ASK), 5, Red );

romper;

/Cierre las órdenes pendientes

case OP_BUYLIMIT :

case OP_BUYSTOP :

case OP_SELLLIMIT :

case OP_SELLSTOP : result = OrderDelete( OrderTicket() );

}

if(result == false)

{

Alert("El pedido " , OrderTicket() , " no se pudo cerrar. Error:" , GetLastError() );

Sleep(3000);

}

}

Print("TODOS LOS PEDIDOS SE CIERRAN-->Cerrado en beneficios");

}

return(0);

}

}

//+------------------------------------------------------------------+

//| Calcular las posiciones abiertas ||

//+------------------------------------------------------------------+

int CalcularPropuestasActual(cadena símbolo)

{

int ord; mkt=0;

//----

for(int i=0;i<TotalOrdenes();i++) {

if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES)==false) continue;

if(OrderSymbol()==symbol && OrderMagicNumber()==MagicNumber) {

ord++;

if (OrderType()==OP_BUY || OrderType()==OP_SELL) mkt++;

}

}

//---- devolver el volumen de las órdenes

return(ord);

}

//+------------------------------------------------------------------+

//| Comprobar las condiciones de las órdenes abiertas ||.

//+------------------------------------------------------------------+

void CheckForSignals() {

//comprobar señales de largo, corto y salida

buysig=false;

sellsig=false;

closebuy=false;

closesell=false;

remorder=false;

int isins,isouts,iskeyrev,is2brev;

if (InsideBar) isins=IsInsideBar(shift);

if (OutSideBar) isouts=IsOutSideBar(shift);

si (KeyReversalBar) iskeyrev=IsKeyReversalBar(shift);

if (TwoBarReversal) is2brev=IsTwoBarReversal(shift);

//condición de señal de entrada larga

si (isins>0 || isouts>0 | iskeyrev>0 | is2brev>0) {

buysig=true;

closesell=true;

}

/señal de entrada en corto

if (isins<0 || isouts<0 | iskeyrev<0 | is2brev<0) {

buysig=false;

sellsig=true;

closebuy=true;

}

if (last>0 && (Time[0]-last)/(Period()*60)>=CancelOrderBars) {

remorder=true;

}

}

void CheckForOpen() {

int res,tr;

//---- condiciones de venta

co=CalcularOrdenesactuales(Symbol());

if(sellsig && lastsig!=-1) {

co=CalcularOrdenesActual(Símbolo());

si (co==0) {

res = OpenStop(OP_SELLSTOP,LotsRisk(StopLoss), Low[shift]-OrderPipsDiff*Point, StopLoss, TakeProfit1);

}

lastsig=-1;

last=Tiempo[0];

return;

}

//---- condiciones de compra

if(buysig && lastsig!=1) {

co=CalcularOrdenesactuales(Símbolo());

if (co==0) {

res = OpenStop(OP_BUYSTOP,LotsRisk(StopLoss), High[shift]+OrderPipsDiff*Point, StopLoss, TakeProfit1);

}

last=Tiempo[0];

last=1;

return;

}

}

void BreakEvenStop(int BES, int BELP) {

//mover el stoploss para bloquear algún beneficio

bool bres;

doble StopLoss;

if ( BES > 2 ) {

for (int i = 0; i < OrdersTotal(); i++) {

if ( OrderSelect (i, SELECT_BY_POS) == false ) continuar;

if ( OrderSymbol() != Symbol() || OrderMagicNumber() != MagicNumber ) continue;

if ( OrderType() == OP_BUY ) {

if ( Bid < OrderOpenPrice()+BES*Point ) continue;

StopLoss = OrderOpenPrice()+BELP*Point;

si ( StopLoss > OrderStopLoss() ) {

bres=OrderModify (OrderTicket(), OrderOpenPrice(), StopLoss, OrderTakeProfit(), 0, White);

if (!bres) Print("Error al modificar la orden BUY : ",ErrorDescription(GetLastError()));

}

}

if ( OrderType() = OP_SELL ) {

if ( Ask > OrderOpenPrice()-BES*Point ) continue;

StopLoss = OrderOpenPrice()-BELP*Point;

si ( StopLoss < OrderStopLoss() ) {

bres=OrderModify (OrderTicket(), OrderOpenPrice(), StopLoss, OrderTakeProfit(), 0, Gold);

if (!bres) Print("Error al modificar la orden SELL : ",ErrorDescription(GetLastError()));

}

}

}

}

return;

}

int IsKeyReversalBar(int shift) {

//Barra de reversión de clave, La apertura de la barra clave debe ser al menos ?pips más alta que el alto de la barra anterior.

/El cierre de la barra clave debe estar con en el alto y el cierre de la barra anterior. La apertura de la barra actual debe ser

//inferior al cierre de la barra clave. Se debe colocar una orden SellStop en el mínimo de la barra clave si no se ejecuta dentro de

//en las siguientes 4 barras, entonces se cancela la orden. Vea la imagen de abajo - ¡corto!

if (Open[shift]=Low[shift+1] && Close[shift]Close[shift]) return(1);

if (Open[shift]>High[shift+1] && Close[shift]=Close[shift+1] && Open[shift-1]<Close[shift]) return(-1);

return(0);

}

int IsTwoBarReversal(int shift) {

/Dos Bares Reversales, La apertura de la primera barra debe estar cerca del mínimo de la barra anterior y el cierre debe ser mucho más bajo y

//tener un cuerpo de buen tamaño. La apertura de la segunda barra debe estar muy cerca del cierre de la primera barra pero ambas deben estar muy por debajo de

//el punto medio de cada barra y el cierre debe estar muy cerca del mínimo de la barra anterior. Se debe colocar una orden BuyStop en el máximo de

//la barra 1 si no se ejecuta dentro de las 4 barras cancelar la orden. Vea la imagen de abajo

if (MathAbs(Open[shift+1]-Close[shift+1])> MathAbs(Open[shift+1]-Low[shift+2])<=

MathAbs(Cierre[turno]-Bajo[turno+2])<=

MathAbs(Apertura[turno]-Cierre[turno+1]) &&

Close[shift+1]<(High[shift+1]+Low[shift+1])/2 &&

Abrir[turno]<(Alto[turno]+Bajo[turno])/2)

return(1);

si (MathAbs(Open[shift+1]-Close[shift+1])> MathAbs(Open[shift+1]-High[shift+2])<=

MathAbs(Cierre[turno]-Bajo[turno+2])<=

MathAbs(Apertura[turno]-Cierre[turno+1]) &&

Close[shift+1]>(High[shift+1]+Low[shift+1])/2 &&

Abrir[turno]>(Alto[turno]+Bajo[turno])/2)

return(-1);

return(0);

}

int OpenStop(int modo,double lote, double prc, int SL, int TP) {

int res,tr,col;

cadena de correo;

double openprice,sl,tp,stlev;

intentos=0;

stlev=(1+MarketInfo(Symbol(),MODE_STOPLEVEL))*Punto;

while (res<=0 && tries<OrderTriesNumber) {

tr=0; while (tr<5 && !IsTradeAllowed()) { tr++; Sleep(2000); }

RefreshRates();

if (mode==OP_SELLSTOP) {

si (prc<=Bid-stlev) openprice=prc;

si no, openprice=Bid-stlev;

si (SL>0) sl=precio abierto+SL*Punto;

si (TP>0) tp=precio abierto-TP*Punto;

col=Rojo;

} si no

si (mode==OP_BUYSTOP) {

si (prc>=Ask+stlev) openprice=prc;

si no, openprice=Ask+stlev;

si (SL>0) sl=precio abierto-SL*Punto;

si (TP>0) tp=precio abierto+TP*Punto;

col=Azul;

} else return;

Print(Ask," ",Bid," ",Symbol()," ",mode," ",lot," ",openprice," ",sl," ",tp," ");

res=EnviarOrden(Símbolo(),modo,lote,precio de apertura,deslizamiento,sl,tp,EAName+"_"+NúmeroMágico,NúmeroMágico,0,col);

intenta++;

}

if (res<=0) Print("Error al abrir una orden pendiente : ",ErrorDescription(GetLastError()));

return(res);

}

void CheckForClose() {

bool bres; int tr;

for(int i=0;i<TotalPedidos();i++) {

if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES)==false) continue;

if(OrderMagicNumber()!=MagicNumber | OrderSymbol()!=Symbol()) continue;

//---- comprueba el tipo de pedido

if(OrderType()==OP_BUY && closebuy) {

bres=CloseAtMarket(OrderTicket(),OrderLots());

continuar;

}

if(OrderType()==OP_SELL && closesell) {

bres=CloseAtMarket(OrderTicket(),OrderLots());

continuar;

}

if(OrderType()==OP_BUYSTOP && (closebuy || remorder)) {

bres=DeletePending(OrderTicket());

continuar;

}

if(OrderType()==OP_SELLSTOP && (closesell | remorder)) {

bres=DeletePending(OrderTicket());

continuar;

}

}

}

bool DeletePending(int ticket) {

bool bres=false; int tr;

tries=0;

while (!bres && tries<OrderTriesNumber) {

bres=OrderDelete(ticket);

tries++;

tr=0; while (tr<5 && !IsTradeAllowed()) { tr++; Sleep(2000); }

}

if (!bres) Print("Error al borrar la orden : ",ErrorDescription(GetLastError()));

return (bres);

}

 

¿Alguien conoce el código para hacer que un EA sólo funcione con un determinado número de cuenta? Gracias.

 

Está aquí https://www.mql5.com/en/forum/174194 (post #7)

 

Tienes demasiadas cosas en este caso

}
 
newdigital:
Es aquí https://www.mql5.com/en/forum/174194 (post #7)

Gracias newdigital.

Tengo mi código de inicialización (que tiene un tiempo de expiración en él) configurado así:

int init()

{if (TimeCurrent()>D'2008.06.07 12:00:00'){Comentario("por favor renueve su suscripción"); return(0);}

return(0);

}

}

if (Account != AccountNumber()){

Comentario("¡Operar en la cuenta : "+NúmeroDeCuenta()+" PROHIBIDO!");

return(0);

}else {Comment("");}

Y ahora me devuelve este error:

'}' - paréntesis desequilibrados

¿Qué estoy haciendo mal aquí? Además, ¿"int Cuenta = 111111;" va con la configuración del EA? Gracias.

1...110111112113114115116117118119120121122123124...182
Nuevo comentario