[RISOLTO] Valore MAX tra 18 elementi?

Mattia_L · October 8, 2019, 2:59pm

Ciao a tutti,

Ho bisogno di sapere qual è il risultato maggiore tra 18 formule diverse per poi eseguire un calcolo...
La funzione max accetta solo due valori, quindi niente.
Ho provato con una serie di if, ma dopo il quinto non da più feedback in seriale.
Come potrei fare?
Grazie!

float Thrust0; float Thrust1; float Thrust2; float Thrust3; float Thrust4; float Thrust5; float Thrust6; float Thrust7; float Thrust8; float Thrust9; float Thrust10; float Thrust11; float Thrust12; float Thrust13; float Thrust14; float Thrust15; float Thrust16; float Thrust17;

    float maxThrust = 0;
    
    Thrust0 = ((0.5*air*(Cl[0])*AWS*AWS*Atot)*sin(radians(AWA))-(0.5*air*(Cd[0])*AWS*AWS*Atot)*cos(radians(AWA)))/1000;
    Thrust1 = ((0.5*air*(Cl[1])*AWS*AWS*Atot)*sin(radians(AWA))-(0.5*air*(Cd[1])*AWS*AWS*Atot)*cos(radians(AWA)))/1000;
    Thrust2 = ((0.5*air*(Cl[2])*AWS*AWS*Atot)*sin(radians(AWA))-(0.5*air*(Cd[2])*AWS*AWS*Atot)*cos(radians(AWA)))/1000;
    Thrust3 = ((0.5*air*(Cl[3])*AWS*AWS*Atot)*sin(radians(AWA))-(0.5*air*(Cd[3])*AWS*AWS*Atot)*cos(radians(AWA)))/1000;
    Thrust4 = ((0.5*air*(Cl[4])*AWS*AWS*Atot)*sin(radians(AWA))-(0.5*air*(Cd[4])*AWS*AWS*Atot)*cos(radians(AWA)))/1000;
    Thrust5 = ((0.5*air*(Cl[5])*AWS*AWS*Atot)*sin(radians(AWA))-(0.5*air*(Cd[5])*AWS*AWS*Atot)*cos(radians(AWA)))/1000;
    Thrust6 = ((0.5*air*(Cl[6])*AWS*AWS*Atot)*sin(radians(AWA))-(0.5*air*(Cd[6])*AWS*AWS*Atot)*cos(radians(AWA)))/1000;
    Thrust7 = ((0.5*air*(Cl[7])*AWS*AWS*Atot)*sin(radians(AWA))-(0.5*air*(Cd[7])*AWS*AWS*Atot)*cos(radians(AWA)))/1000;
    Thrust8 = ((0.5*air*(Cl[8])*AWS*AWS*Atot)*sin(radians(AWA))-(0.5*air*(Cd[8])*AWS*AWS*Atot)*cos(radians(AWA)))/1000;
    Thrust9 = ((0.5*air*(Cl[9])*AWS*AWS*Atot)*sin(radians(AWA))-(0.5*air*(Cd[9])*AWS*AWS*Atot)*cos(radians(AWA)))/1000;
    Thrust10 = ((0.5*air*(Cl[10])*AWS*AWS*Atot)*sin(radians(AWA))-(0.5*air*(Cd[10])*AWS*AWS*Atot)*cos(radians(AWA)))/1000;
    Thrust11 = ((0.5*air*(Cl[11])*AWS*AWS*Atot)*sin(radians(AWA))-(0.5*air*(Cd[11])*AWS*AWS*Atot)*cos(radians(AWA)))/1000;
    Thrust12 = ((0.5*air*(Cl[12])*AWS*AWS*Atot)*sin(radians(AWA))-(0.5*air*(Cd[12])*AWS*AWS*Atot)*cos(radians(AWA)))/1000;
    Thrust13 = ((0.5*air*(Cl[13])*AWS*AWS*Atot)*sin(radians(AWA))-(0.5*air*(Cd[13])*AWS*AWS*Atot)*cos(radians(AWA)))/1000;
    Thrust14 = ((0.5*air*(Cl[14])*AWS*AWS*Atot)*sin(radians(AWA))-(0.5*air*(Cd[14])*AWS*AWS*Atot)*cos(radians(AWA)))/1000;
    Thrust15 = ((0.5*air*(Cl[15])*AWS*AWS*Atot)*sin(radians(AWA))-(0.5*air*(Cd[15])*AWS*AWS*Atot)*cos(radians(AWA)))/1000;
    Thrust16 = ((0.5*air*(Cl[16])*AWS*AWS*Atot)*sin(radians(AWA))-(0.5*air*(Cd[16])*AWS*AWS*Atot)*cos(radians(AWA)))/1000;
    Thrust17 = ((0.5*air*(Cl[17])*AWS*AWS*Atot)*sin(radians(AWA))-(0.5*air*(Cd[17])*AWS*AWS*Atot)*cos(radians(AWA)))/1000;


    maxThrust = Thrust0;
    if(maxThrust < Thrust1) {
      maxThrust = Thrust1;
      //Serial.println(maxThrust, 5);
      //Serial.println(Thrust1);
    }
    if(maxThrust < Thrust2) {
      maxThrust = Thrust2;
      //Serial.println(maxThrust, 5);
      //Serial.println(Thrust2);
    }
    if(maxThrust < Thrust3) {
      maxThrust = Thrust3;
      //Serial.println(maxThrust, 5);
      //Serial.println(Thrust3);
    }
    if(maxThrust < Thrust4) {
      maxThrust = Thrust4;
      //Serial.println(maxThrust, 5);
      //Serial.println(Thrust4);
    }
    if(maxThrust < Thrust5) {
      maxThrust = Thrust5;
      Serial.println(maxThrust, 5);
      Serial.println(Thrust5);
    }

nid69ita · October 8, 2019, 3:02pm

DEVI usare un vettore/array, ovvero un contenitore con nome unico e con un indice accedi ai vari elementi.
Questo permette di lavorare con cicli for su tutti gli elementi.
Studiati su un sito o libro i vettori/array del linguaggio C

P.S. i tuoi Cl e Cs già sono degli array

Mattia_L · October 8, 2019, 3:16pm

E dopo...

float Thrust[18];

    Thrust[0] = ((0.5*air*(Cl[0])*AWS*AWS*Atot)*sin(radians(AWA))-(0.5*air*(Cd[0])*AWS*AWS*Atot)*cos(radians(AWA)))/1000;
    Thrust[1] = ((0.5*air*(Cl[1])*AWS*AWS*Atot)*sin(radians(AWA))-(0.5*air*(Cd[1])*AWS*AWS*Atot)*cos(radians(AWA)))/1000;
    Thrust[2] = ((0.5*air*(Cl[2])*AWS*AWS*Atot)*sin(radians(AWA))-(0.5*air*(Cd[2])*AWS*AWS*Atot)*cos(radians(AWA)))/1000;
    Thrust[3] = ((0.5*air*(Cl[3])*AWS*AWS*Atot)*sin(radians(AWA))-(0.5*air*(Cd[3])*AWS*AWS*Atot)*cos(radians(AWA)))/1000;
    Thrust[4] = ((0.5*air*(Cl[4])*AWS*AWS*Atot)*sin(radians(AWA))-(0.5*air*(Cd[4])*AWS*AWS*Atot)*cos(radians(AWA)))/1000;
    Thrust[5] = ((0.5*air*(Cl[5])*AWS*AWS*Atot)*sin(radians(AWA))-(0.5*air*(Cd[5])*AWS*AWS*Atot)*cos(radians(AWA)))/1000;
    Thrust[6] = ((0.5*air*(Cl[6])*AWS*AWS*Atot)*sin(radians(AWA))-(0.5*air*(Cd[6])*AWS*AWS*Atot)*cos(radians(AWA)))/1000;
    Thrust[7] = ((0.5*air*(Cl[7])*AWS*AWS*Atot)*sin(radians(AWA))-(0.5*air*(Cd[7])*AWS*AWS*Atot)*cos(radians(AWA)))/1000;
    Thrust[8] = ((0.5*air*(Cl[8])*AWS*AWS*Atot)*sin(radians(AWA))-(0.5*air*(Cd[8])*AWS*AWS*Atot)*cos(radians(AWA)))/1000;
    Thrust[9] = ((0.5*air*(Cl[9])*AWS*AWS*Atot)*sin(radians(AWA))-(0.5*air*(Cd[9])*AWS*AWS*Atot)*cos(radians(AWA)))/1000;
    Thrust[10] = ((0.5*air*(Cl[10])*AWS*AWS*Atot)*sin(radians(AWA))-(0.5*air*(Cd[10])*AWS*AWS*Atot)*cos(radians(AWA)))/1000;
    Thrust[11] = ((0.5*air*(Cl[11])*AWS*AWS*Atot)*sin(radians(AWA))-(0.5*air*(Cd[11])*AWS*AWS*Atot)*cos(radians(AWA)))/1000;
    Thrust[12] = ((0.5*air*(Cl[12])*AWS*AWS*Atot)*sin(radians(AWA))-(0.5*air*(Cd[12])*AWS*AWS*Atot)*cos(radians(AWA)))/1000;
    Thrust[13] = ((0.5*air*(Cl[13])*AWS*AWS*Atot)*sin(radians(AWA))-(0.5*air*(Cd[13])*AWS*AWS*Atot)*cos(radians(AWA)))/1000;
    Thrust[14] = ((0.5*air*(Cl[14])*AWS*AWS*Atot)*sin(radians(AWA))-(0.5*air*(Cd[14])*AWS*AWS*Atot)*cos(radians(AWA)))/1000;
    Thrust[15] = ((0.5*air*(Cl[15])*AWS*AWS*Atot)*sin(radians(AWA))-(0.5*air*(Cd[15])*AWS*AWS*Atot)*cos(radians(AWA)))/1000;
    Thrust[16] = ((0.5*air*(Cl[16])*AWS*AWS*Atot)*sin(radians(AWA))-(0.5*air*(Cd[16])*AWS*AWS*Atot)*cos(radians(AWA)))/1000;
    Thrust[17] = ((0.5*air*(Cl[17])*AWS*AWS*Atot)*sin(radians(AWA))-(0.5*air*(Cd[17])*AWS*AWS*Atot)*cos(radians(AWA)))/1000;

    for(float BestThrust = 0; BestThrust < 18; BestTrust++) {
      
    }

gpb01 · October 8, 2019, 3:21pm

Imposti una variabile, ad esempio 'massimo' di tipo float a 0.0, dopo di che nel ciclo for la compari con ogni elemento; se essa è maggiore o uguale, non fai nulla, se è minore assegni quell'elemento alla variabile.
Alla fine del for, la variabile che abbiamo chiamato 'massimo' conterrà il valore massimo trovato.

Guglielmo

Mattia_L · October 8, 2019, 3:33pm

Così?...

for(int i = 0; i < 18; i++) {
      if(massimo < Thrust[i]) {
        massimo = Thrust[i];
      }
    }
    BestThrust = massimo;
    Serial.print(BestThrust, 5);

gpb01 · October 8, 2019, 3:58pm

Lo hai provato ? ... è il miglior modo per sapere se hai fatto bene

Guglielmo

P.S.: Perché per stampare 'massimo' lo assegni ad un'altra variabile? Allora potevi usare direttmente quella allo stesso modo ... ogni 'float' che dichiari si mangia ben 4 bytes della preziosa SRAM, quindi ... impara ad evitare gli sprechi ...

paolo311 · October 9, 2019, 7:00am

I valori vengono calcolati sulla base di una funzione che è sempre la stessa e che dipende da un indice:

float myDummyFunct(int index)
{
     return ((0.5*air*(Cl[index])*AWS*AWS*Atot)*sin(radians(AWA))-(0.5*air*(Cd[index])*AWS*AWS*Atot)*cos(radians(AWA)))/1000;
}

Quindi puoi anche evitare di fare l'array:

float maxValue = myDummyFunct(0);
for(int i = 1; i < 18; i++)
{
     float tmp = myDummyFunct(i);
     maxVaue = tmp > maxValue ? tmp : maxValue;
}

Mattia_L · October 9, 2019, 7:11am

Dovrebbe essere giusto così controllerò i calcoli.

Sisi elimino "massimo"... era solo per una prova veloce.

Grazie a tutti!

Mattia_L · October 9, 2019, 10:54am

C'è un altro problema...

Quando AWA aumenta, il risultato più alto tra i calcoli viene mostrato correttamente.
Quando diminuisce invece, il risultato non cambia. Rimane l'ultimo trovato... non si aggiorna...

Come mai?

gpb01 · October 9, 2019, 11:12am

Scusa, ma se cerchi il massimo, sempre il massimo ti da.

Se la serie di valori cambia, prima devi di nuovo azzerare la variabile che usi per salvare il massimo, altrimenti sempre il vecchio massimo dentro c'è (vado a naso, visto che non hai messo il codice che stai usando).

Guglielmo

Mattia_L · October 9, 2019, 12:41pm

Dovrei azzerare le variabili fuori da questo void, perchè l'AngleOfAttack poi mi serve, e non voglio che si azzeri prima di averlo usato, giusto?

void calcTHR() {
  if(time>calcola_THR_time + 3000) {
    Thrust[0] = ((0.5*air*(Cl[0])*AWS*AWS*Atot)*sin(radians(AWA))-(0.5*air*(Cd[0])*AWS*AWS*Atot)*cos(radians(AWA)))/1000;
    Thrust[1] = ((0.5*air*(Cl[1])*AWS*AWS*Atot)*sin(radians(AWA))-(0.5*air*(Cd[1])*AWS*AWS*Atot)*cos(radians(AWA)))/1000;
    Thrust[2] = ((0.5*air*(Cl[2])*AWS*AWS*Atot)*sin(radians(AWA))-(0.5*air*(Cd[2])*AWS*AWS*Atot)*cos(radians(AWA)))/1000;
    Thrust[3] = ((0.5*air*(Cl[3])*AWS*AWS*Atot)*sin(radians(AWA))-(0.5*air*(Cd[3])*AWS*AWS*Atot)*cos(radians(AWA)))/1000;
    Thrust[4] = ((0.5*air*(Cl[4])*AWS*AWS*Atot)*sin(radians(AWA))-(0.5*air*(Cd[4])*AWS*AWS*Atot)*cos(radians(AWA)))/1000;
    Thrust[5] = ((0.5*air*(Cl[5])*AWS*AWS*Atot)*sin(radians(AWA))-(0.5*air*(Cd[5])*AWS*AWS*Atot)*cos(radians(AWA)))/1000;
    Thrust[6] = ((0.5*air*(Cl[6])*AWS*AWS*Atot)*sin(radians(AWA))-(0.5*air*(Cd[6])*AWS*AWS*Atot)*cos(radians(AWA)))/1000;
    Thrust[7] = ((0.5*air*(Cl[7])*AWS*AWS*Atot)*sin(radians(AWA))-(0.5*air*(Cd[7])*AWS*AWS*Atot)*cos(radians(AWA)))/1000;
    Thrust[8] = ((0.5*air*(Cl[8])*AWS*AWS*Atot)*sin(radians(AWA))-(0.5*air*(Cd[8])*AWS*AWS*Atot)*cos(radians(AWA)))/1000;
    Thrust[9] = ((0.5*air*(Cl[9])*AWS*AWS*Atot)*sin(radians(AWA))-(0.5*air*(Cd[9])*AWS*AWS*Atot)*cos(radians(AWA)))/1000;
    Thrust[10] = ((0.5*air*(Cl[10])*AWS*AWS*Atot)*sin(radians(AWA))-(0.5*air*(Cd[10])*AWS*AWS*Atot)*cos(radians(AWA)))/1000;
    Thrust[11] = ((0.5*air*(Cl[11])*AWS*AWS*Atot)*sin(radians(AWA))-(0.5*air*(Cd[11])*AWS*AWS*Atot)*cos(radians(AWA)))/1000;
    Thrust[12] = ((0.5*air*(Cl[12])*AWS*AWS*Atot)*sin(radians(AWA))-(0.5*air*(Cd[12])*AWS*AWS*Atot)*cos(radians(AWA)))/1000;
    Thrust[13] = ((0.5*air*(Cl[13])*AWS*AWS*Atot)*sin(radians(AWA))-(0.5*air*(Cd[13])*AWS*AWS*Atot)*cos(radians(AWA)))/1000;
    Thrust[14] = ((0.5*air*(Cl[14])*AWS*AWS*Atot)*sin(radians(AWA))-(0.5*air*(Cd[14])*AWS*AWS*Atot)*cos(radians(AWA)))/1000;
    Thrust[15] = ((0.5*air*(Cl[15])*AWS*AWS*Atot)*sin(radians(AWA))-(0.5*air*(Cd[15])*AWS*AWS*Atot)*cos(radians(AWA)))/1000;
    Thrust[16] = ((0.5*air*(Cl[16])*AWS*AWS*Atot)*sin(radians(AWA))-(0.5*air*(Cd[16])*AWS*AWS*Atot)*cos(radians(AWA)))/1000;
    Thrust[17] = ((0.5*air*(Cl[17])*AWS*AWS*Atot)*sin(radians(AWA))-(0.5*air*(Cd[17])*AWS*AWS*Atot)*cos(radians(AWA)))/1000;

    for(int i = 0; i < 18; i++) {
      if(BestThrust < Thrust[i]) {
        BestThrust = Thrust[i];
      }
    }

    if(TWA180 > 0 && TWA180 < 180) {
      
      if(BestThrust == Thrust[0]) {
        AngleOfAttack = MasterAngle[0];
      }
      else if(BestThrust == Thrust[1]) {
        AngleOfAttack = MasterAngle[1];
      }
      else if(BestThrust == Thrust[2]) {
        AngleOfAttack = MasterAngle[2];
      }
      else if(BestThrust == Thrust[3]) {
        AngleOfAttack = MasterAngle[3];
      }
      else if(BestThrust == Thrust[4]) {
        AngleOfAttack = MasterAngle[4];
      }
      else if(BestThrust == Thrust[5]) {
        AngleOfAttack = MasterAngle[5];
      }
      else if(BestThrust == Thrust[6]) {
        AngleOfAttack = MasterAngle[6];
      }
      else if(BestThrust == Thrust[7]) {
        AngleOfAttack = MasterAngle[7];
      }
      else if(BestThrust == Thrust[8]) {
        AngleOfAttack = MasterAngle[8];
      }
      else if(BestThrust == Thrust[9]) {
        AngleOfAttack = MasterAngle[9];
      }
      else if(BestThrust == Thrust[10]) {
        AngleOfAttack = MasterAngle[10];
      }
      else if(BestThrust == Thrust[11]) {
        AngleOfAttack = MasterAngle[11];
      }
      else if(BestThrust == Thrust[12]) {
        AngleOfAttack = MasterAngle[12];
      }
      else if(BestThrust == Thrust[13]) {
        AngleOfAttack = MasterAngle[13];
      }
      else if(BestThrust == Thrust[14]) {
        AngleOfAttack = MasterAngle[14];
      }
      else if(BestThrust == Thrust[15]) {
        AngleOfAttack = MasterAngle[15];
      }
      else if(BestThrust == Thrust[16]) {
        AngleOfAttack = MasterAngle[16];
      }
      else if(BestThrust == Thrust[17]) {
        AngleOfAttack = MasterAngle[17];
      }

    } else if(TWA360 > 180 && TWA360 < 360) {
        
        if(BestThrust == Thrust[0]) {
          AngleOfAttack = 360-MasterAngle[17];
        }
        else if(BestThrust == Thrust[1]) {
          AngleOfAttack = 360-MasterAngle[16];
        }
        else if(BestThrust == Thrust[2]) {
          AngleOfAttack = 360-MasterAngle[15];
        }
        else if(BestThrust == Thrust[3]) {
          AngleOfAttack = 360-MasterAngle[14];
        }
        else if(BestThrust == Thrust[4]) {
          AngleOfAttack = 360-MasterAngle[13];
        }
        else if(BestThrust == Thrust[5]) {
          AngleOfAttack = 360-MasterAngle[12];
        }
        else if(BestThrust == Thrust[6]) {
          AngleOfAttack = 360-MasterAngle[11];
        }
        else if(BestThrust == Thrust[7]) {
          AngleOfAttack = 360-MasterAngle[10];
        }
        else if(BestThrust == Thrust[8]) {
          AngleOfAttack = 360-MasterAngle[9];
        }
        else if(BestThrust == Thrust[9]) {
          AngleOfAttack = 360-MasterAngle[8];
        }
        else if(BestThrust == Thrust[10]) {
          AngleOfAttack = 360-MasterAngle[7];
        }
        else if(BestThrust == Thrust[11]) {
          AngleOfAttack = 360-MasterAngle[6];
        }
        else if(BestThrust == Thrust[12]) {
          AngleOfAttack = 360-MasterAngle[5];
        }
        else if(BestThrust == Thrust[13]) {
          AngleOfAttack = 360-MasterAngle[4];
        }
        else if(BestThrust == Thrust[14]) {
          AngleOfAttack = 360-MasterAngle[3];
        }
        else if(BestThrust == Thrust[15]) {
          AngleOfAttack = 360-MasterAngle[2];
        }
        else if(BestThrust == Thrust[16]) {
          AngleOfAttack = 360-MasterAngle[1];
        }
        else if(BestThrust == Thrust[17]) {
          AngleOfAttack = 360-MasterAngle[0];
        }

    }

    //Serial.println(BestThrust, 5);
    //Serial.println(AngleOfAttack);
    
    calcola_THR_time=millis();
  }
}

void loop() {
  time=millis();

    leggiAWS();
    leggiAWA();
    scriviSuDisplay();

    calcTW();
    //calcTHR();
    
    scriviSuMicroSD();


    if(AWS < 9) {
      digitalWrite(green_led, HIGH);
      digitalWrite(red_led, LOW);
      digitalWrite(yellow_led, LOW);

      
      if(TWA180 > 0 && TWA180 < 180) {
        calcTHR();
        myStepper.run();
        angle = AngleOfAttack*gear_ratio;
        myStepper.moveTo(-angle/stepPerAngle);
      }
      else if(TWA360 > 180 && TWA360 < 360) {
        calcTHR();
        myStepper.run();
        angle = AngleOfAttack*gear_ratio;
        myStepper.moveTo(-angle/stepPerAngle);
      }

gpb01 · October 9, 2019, 1:20pm

Devi azzerare quella che ogni volta usi per calcolare il massimo, mi sembra BestThrust ... :

Ti suggerisco anche di imparare ad usare bene il ciclo FOR ... il tuo programma si ridurrebbe di parecchio

Guglielmo

nid69ita · October 9, 2019, 1:24pm

Boh, ti diciamo di usare i vettori perchè così puoi usare i cicli for e non lo fai.

Thrust[0] = ((0.5*air*(Cl[0])*AWS*AWS*Atot)*sin(radians(AWA))-(0.5*air*(Cd[0])*AWS*AWS*Atot)*cos(radians(AWA)))/1000;
Thrust[1] = ((0.5*air*(Cl[1])*AWS*AWS*Atot)*sin(radians(AWA))-(0.5*air*(Cd[1])*AWS*AWS*Atot)*cos(radians(AWA)))/1000;
etc.

diventa

for(int i=0;i<=17;i++)
{ Thrust[i] = ((0.5*air*(Cl[i])*AWS*AWS*Atot)*sin(radians(AWA))-(0.5*air*(Cd[i])*AWS*AWS*Atot)*cos(radians(AWA)))/1000;
}

paolo311 · October 9, 2019, 1:33pm

(scusate risposta doppia..)

Oltretutto a te non serve il valore massimo, ma l'indice corrispondente..

    int maxIndex = -1;
    for(int i = 0; i < 18; i++) {
      if(BestThrust < Thrust[i]) {
        BestThrust = Thrust[i];
        maxIndex = i;
      }
    }

In modo che poi l'If kilometrico diventa semplicemente:

    if(TWA180 > 0 && TWA180 < 180) 
    {
        AngleOfAttack = MasterAngle[maxIndex];
    } 
    else if(TWA360 > 180 && TWA360 < 360) 
    {
        AngleOfAttack = 360-MasterAngle[17 - maxIndex];
    }

Mattia_L · October 9, 2019, 3:09pm

Okay grazie.
Non mi è chiaro questo...

AngleOfAttack = 360-MasterAngle[17 - maxIndex];

L'ultimo indice MasterAngle meno l'indice della formula che da il massimo risultato come fa ad associare l'indice della formula all'indice corrispondente del MasterAngle?

Da 0 a 180 gradi funziona (con BestThrust = 0 prima di int maxIndex), da 180 a 360 però no..

paolo311 · October 9, 2019, 3:24pm

Mattia_L:
Okay grazie.
Non mi è chiaro questo...
AngleOfAttack = 360-MasterAngle[17 - maxIndex];

Nel tuo codice originario facevi così:

if(BestThrust == Thrust[0]) 
{
          AngleOfAttack = 360-MasterAngle[17];
}
else if(BestThrust == Thrust[1]) 
{
          AngleOfAttack = 360-MasterAngle[16];
}

Cioè se il bestThrust era all'indice 0, usavi l'elemento masterAngle all'indice 17, all'1 il 16 e così via..
In pratica associ ad un indice il suo complementare e per trovare il complementare di un valore basta sottrarlo al valore massimo.

Ricavando l'indice di MasterAngle in base a quello di thrust riesci a metterli in relazione senza utilizzare 17 if differenti.

ciao

Mattia_L · October 10, 2019, 7:01am

Okay grazie ho capito.

Adesso però funziona solo se l'AWA è minore di 180. Quando è maggiore, l'AngleOfAttack da sempre 360...

if(AWA < 180) {
      AngleOfAttack = MasterAngle[maxIndex];
    }
    else if(AWA > 180) {
      AngleOfAttack = 360-MasterAngle[17-maxIndex];
      Serial.println(AngleOfAttack);
    }

gpb01 · October 10, 2019, 1:23pm

>Mattia_L: ti rammento che da REGOLAMENTO NON è permesso fare "up" (sollecitare risposte), prima di 48 ore dall'ultimo post. Grazie.

Guglielmo

paolo311 · October 10, 2019, 4:27pm

Mattia_L:
Okay grazie ho capito.

Adesso però funziona solo se l'AWA è minore di 180. Quando è maggiore, l'AngleOfAttack da sempre 360...

Posta il contenuto dell'array thrust e di quello maxAngle in una delle esecuzioni errate.

Mattia_L · October 11, 2019, 7:15am

Thrust
0.00
-0.11
-0.22
-0.32
-0.42
-0.51
-0.59
-0.60
-0.55
-0.49
-0.46
-0.47
-0.49
-0.45
-0.36
-0.24
-0.10
0.05

BestThrust 0.05
maxIndex 17
AngleOfAttack 360.00

Topic		Replies	Views
Ricavare valore più alto Software	3	615	May 7, 2021
visualizzare valore massimo Software	8	1143	May 7, 2021
[Risolto] Confronto di variabili con approssimazione Software	17	4664	May 7, 2021
Conversione formula matematica in codice Software	9	1429	May 7, 2021
Confronto tra elementi array Software	6	2519	May 7, 2021

[RISOLTO] Valore MAX tra 18 elementi?

Related topics