buy sell ea

[MA-EA]

Hallo.


Im Anhang ein erster Versuch, zu hedgen und immer wieder die Order-Anzahl zu erhöhen, statt den Einsatz. Er sollen erst mal ein Sell und ein Buy öffnen. Je nachdem in wessen Richtung der Kurs geht, sollen nach einer bestimmten Bewegung 2 Weitere Orders in die Richtung geöffnet werden, beim nächsten mal 4 Weitere Orders und immer so weiter. Wenn irgendwann ein bestimmter "Gewinn-Bereich" erreicht wurde, sollen sämtliche Orders geschlossen, alle Zähler zurück gesetzt und das ganze Spiel von vorn begonnen werden. Sollte der Kurs vorher drehen, müssten doppelt so viele Orders in die neue Richtung geöffnet werden (wenn ich mich nicht irre ). Klingt eigentlich einfach, ist es für mich Anfänger aber nicht.


Im Anhang ein erster Ansatz, so einen EA zu proggen. Sind haufenweise Fehler drin und viele Sachen sind noch lange nicht fertig. Wär dankbar für jeden Tipp oder Hinweis, wie man das Ding proggen könnte/müsste.

[Indikator-Trading]

16 Compilerfehler... lass dir von TraderDoc helfen, der macht dir bestimmt einen Freundschaftspreis

[Ca$hDigger]

Ganz meine Rede

Zitat von Ca$hDigger

@Martin
schau doch mal in traderdocs Signatur oder anders gesagt, lass dir das Ding einfach professionell von jemanden schreiben.

Ab einem bestimmten Punkt sollte man die Sachen outsourcen am Ende hat man sonst Wochen seiner Lebenszeit verschwendet und trotzdem noch Buggy Code
Selbst Profis outsourcen noch mache Sachen weil es ein Anderer in einem bestimmten Bereich einfach schneller und besser kann ist völlig normal.

[MA-EA]

Die Fehler im Code sind nicht das Problem, sondern die Umsetzung der Strategie. Wie gesagt ist der EA noch lange nicht fertig.

Mehrmals müssen Orders gesucht, selektiert, ihre Werte geprüft, Berechnungen gemacht und mehrere Werte gezählt/erhöht/multipliziert und zum Schluss zurück gesetzt werden.


Zur Strategie noch mal:

1.
Eine 1.Sell- und eine 1.Buy-Order öffnen

2.
Von deren OrderOpenPrice() wird ne Art Distanz berechnet. Wenn der jeweilige Ask/Bid drüber/drunter ist, soll ne weitere Order in Gewinn-Richtung geöffnet werden. Sollte der Kurs danach drehn, müssten doppelt so viele Orders in die andere Richtung geöffnet werden, also muss eine Variable immer die Orders einer Richtung zählen und dann multipliziert werden.

3.
Wenn die neuen Orders auch in Gewinn-Richtung gehn, muss von deren OOP() wieder ne Distanz berechnet werden, bei der weitere Orders geöffnet und deren Anzahl wieder multipliziert wird, für den Fall, dass der Kurs doch noch dreht.

4.
Wenn irgendwann eine der 1. Orders eine bestimmte Distanz zu ihrem OOP() erreicht, sollen alle noch offenen Orders geschlossen und alle geänderten Werte auf 0 zurück gesetzt werden. Dann soll das Ganze von vorn los gehn.

[MA-EA]

Hallo.

Im Anhang die neueste Version. Beim Kompilieren gibts keine Fehlermeldungen. Mit Sicherheit ist aber noch der ein oder andere Wurm drin und bestimmt kann man Einiges besser und einfacher machen.

Wär dankbar für Tipps.

Ich glaube, man kann das Gerät am Ehesten mit nem Schneeballsystem vergleichen. Um so weiter Ask/Bid in Gewinn-Richtung der jeweiligen Sell/Buy-Orders gehn, desto mehr Orders werden nach und nach in diese Richtung geöffnet. Zumindest soll das Ding irgendwann mal so funktionieren.

Nacht.

[MA-EA]

Abend.

Im Anhang die neueste Version. Sollte besser funktionieren als die von gestern. Zumindest, wenn sie irgendwann mal tat/tut was sie soll.


Frage zu meinem Lieblings-Thema:for-Schleife.

Wenn der EA eine bestimmte Anzahl von Orders öffnen soll, und dabei gleich die Werte erhöhen soll, die ihm sagen, wie viele Sell-/Buy-Orders er später vielleicht mal öffnen soll, ist das dann wenigstens ein bißchen richtig? Die Anzahl, die er beim nächsten Mal öffnen soll, wird im Lauf des Programms immer wieder erhöht. Oder sollte sie zumindest.

// ...FirstSell öffnen:
  if(IsTradeAllowed()==true){
    TI_FiSel=OrderSend(Symbol(),OP_SELL,Lots,Bid,Slippage,SL_Sel,0.0,NULL,MN_FirstSel,clrYellow);
    if(IsTradeContextBusy()==true)Sleep(slMS);
    Opened_Sel++;
    Need_Sel = Opened_Sel * OrdersNeed_Multi;}

// ...FirstBuy öffnen:
  if(IsTradeAllowed()==true){
    TI_FiBuy=OrderSend(Symbol(),OP_BUY,Lots,Ask,Slippage,SL_Buy,0.0,NULL,MN_FirstBuy,clrOrange);
    if(IsTradeContextBusy()==true)Sleep(slMS);
    Opened_Buy++;
    Need_Buy = Opened_Buy * OrdersNeed_Multi;}

 }

//=============================================================================================================
 // O P E N   F I R S T   N E X T   O R D E R S
//=============================================================================================================
// Wenn nur FirstSell und FirstBuy offen sind,
// bei entsprechenden Bedingungen
// next Sel / next Buy öffnen.
if(fiSH==true&&fiLO==true&&neSH==false&&neLO==false){
//-----------------------------------------------------------------------------------------------------------*/

// Wenn FirstSell Bedingungen erfüllt,
// next Sell öffnen.
if(OrderSelect(TI_FiSel,SELECT_BY_TICKET)){
  if(OrderSymbol()==Symbol()){ // ?
      
    FiSelOOP_DistONO=NormalizeDouble( OrderOpenPrice() - Dist_ONO*_Point,_Digits);

    if(Bid <= FiSelOOP_DistONO){
  
      FL_opSel=Opened_Sel; // ?
      FL_neSel=Need_Sel;  // ?
      for( k=FL_opSel ; k<FL_neSel ; k--){
        if(IsTradeAllowed()==true)TI_NeSel=OrderSend(Symbol(),OP_SELL,Lots,Bid,Slippage,SL_Sel,0.0,NULL,MN_NextSel,clrYellow);
        if(IsTradeContextBusy()==true)Sleep(slMS);

        Opened_Sel++;

        Need_Sel = Opened_Sel * OrdersNeed_Multi;

        Need_Buy = Need_Sel * OrdersNeed_Multi;}

} } }

//-----------------------------------------------------------------------------------------------------------*/

// Wenn 1.Buy Bedingungen erfüllt,
// next Buy öffnen.
if(OrderSelect(TI_FiBuy,SELECT_BY_TICKET)){
  if(OrderSymbol()==Symbol()){
       
    FiBuyOOP_DistONO=NormalizeDouble( OrderOpenPrice() + Dist_ONO*_Point,_Digits);

    if(Ask>=FiBuyOOP_DistONO){
    
      FL_opBuy=Opened_Buy; // ?
      FL_neBuy=Need_Buy;  // ?
      for( l=FL_opBuy ; l<FL_neBuy ; l--){
        if(IsTradeAllowed()==true)TI_NeBuy=OrderSend(Symbol(),OP_BUY,Lots,Bid,Slippage,SL_Buy,0.0,NULL,MN_NextBuy,clrYellow);
        if(IsTradeContextBusy()==true)Sleep(slMS);
          
        Opened_Buy++;
      
        Need_Buy = Opened_Buy * OrdersNeed_Multi;
          
        Need_Sel = Need_Buy * OrdersNeed_Multi;}

} } }

//-----------------------------------------------------------------------------------------------------------*/
 }

//=============================================================================================================
 // C H E C K   F I R S T   O R D E R S   A N D   O P E N   N E X T   O R D E R S
//=============================================================================================================
// Wenn FirstSell und FirstBuy offen sind...
if(fiSH==true&&fiLO==true){
// ...und nextSell oder nextBuy offen sind,
if(neSH==true||neLO==true){
// Weitere nextOrders öffnen,
// wenn Bedingungen erfüllt sind.
//-----------------------------------------------------------------------------------------------------------*/
// next Sell über Ticket auswählen.     
if(OrderSelect(TI_NeSel,SELECT_BY_TICKET)){
  if(OrderSymbol()==Symbol()){

//  Prüfen, ob nextSell OpenNextOrder-Dist erreicht hat.
    NeSelOOP_DistONO=NormalizeDouble( OrderOpenPrice() - Dist_ONO*_Point,_Digits );
    if(Bid <= NeSelOOP_DistONO){

//    Wenn ja, FirstSell über Ticket auswählen.
      if(OrderSelect(TI_FiSel,SELECT_BY_TICKET)){
        if(OrderSymbol()==Symbol()){ // ?
   
//        Prüfen, ob 1.Sell Gewinn-Distanz erreicht hat.
          FiSelOOP_DistCAO=NormalizeDouble( OrderOpenPrice() - Dist_CAO *_Point,_Digits);
          if( Ask > FiSelOOP_DistCAO ){

//          Wenn 1.Sell Gewinn-Distanz nicht erreicht hat, weitere Sell-Orders öffnen.
            FL_opSel=Opened_Sel; // ?
            FL_neSel=Need_Sel;  // ?
            for( n=FL_opSel ; n<FL_neSel ; n--){
              if(IsTradeAllowed()==true)TI_NeSel=OrderSend(Symbol(),OP_SELL,Lots,Bid,Slippage,SL_Sel,0.0,NULL,MN_NextSel,clrYellow);
              if(IsTradeContextBusy()==true)Sleep(slMS);

              Opened_Sel++;

              Need_Sel = Opened_Sel * OrdersNeed_Multi;

              Need_Buy = Need_Sel * OrdersNeed_Multi;}

} } } } } }

//-----------------------------------------------------------------------------------------------------------*/

// NextBuy über Ticket auswählen.
if(OrderSelect(TI_NeBuy,SELECT_BY_TICKET)){
  if(OrderSymbol()==Symbol()){

//  Prüfen, ob NextBuy OpenNextOrder-Dist erreicht hat.
    NeBuyOOP_DistONO=NormalizeDouble(OrderOpenPrice() + Dist_ONO*_Point,_Digits);
    if(Ask >= NeBuyOOP_DistONO){

//    Wenn ja, FirstBuy über Ticket auswählen.
      if(OrderSelect(TI_FiBuy,SELECT_BY_TICKET)){
        if(OrderSymbol()==Symbol()){
    
//        Prüfen, ob 1.Buy Gewinn-Distanz erreicht hat.   
          FiBuyOOP_DistCAO=NormalizeDouble( OrderOpenPrice() + Dist_CAO*_Point,_Digits);

//          Wenn 1.Buy Gewinn-Distanz nicht erreicht hat
//          weitere Buy-Orders öffnen.
            if(Bid < FiBuyOOP_DistCAO){

              FL_opBuy=Opened_Buy; // ?
              FL_neBuy=Need_Buy;  // ?
              for( o=FL_opBuy ; o<FL_neBuy ; o--){
                if(IsTradeAllowed()==true)TI_NeBuy=OrderSend(Symbol(),OP_BUY,Lots,Bid,Slippage,SL_Buy,0.0,NULL,MN_NextBuy,clrYellow);
                if(IsTradeContextBusy()==true)Sleep(slMS);
          
                Opened_Buy++;
      
                Need_Buy = Opened_Buy * OrdersNeed_Multi;
          
                Need_Sel = Need_Buy * OrdersNeed_Multi;}

} } } } } }

//-----------------------------------------------------------------------------------------------------------*/
} }