Aiuto stima potenza di calcolo

Buongiorno a tutti, sono nuovo del forum ed è la prima volta che mi interesso ad Arduino, per questo ho alcune domande da porvi. Ho bisogno di realizzare un sistema che possa ricevere dei dati tramite seriale ed elaborarli in tempo reale. Mi spiego meglio, ho un dispositivo che mi comunica tramite seriale alcuni valori reali, diciamo dieci, ogni 20ms, il sistema li deve elaborare eseguendo molte moltiplicazioni, circa mille, e scrivermi qualcosa su un display. Vi chiedo se è fattibile con un sistema Arduino, in particolare se avrei sufficiente capacità di calcolo per eseguire le operazioni necessarie, l'importante è riuscire ad eseguire un ciclo di elaborazione ogni 20ms.

Grazie in anticipo per le risposte.

Se queste mille moltiplicazioni sono esclusivamente tra numeri di tipo char (8bit), se la parte dei calcoli la ottimizzi bene scrivendola in ANSI C diciamo che ce la fai e ti avanza pure qualche ms. Se i calcoli sono tra numeri interi (16 bit), o, peggio, long int/float (32 bit) non ce la fai.

void Stabilizzazione::update(float* data) {
    float norm;
    float vx, vy, vz;
    float ex, ey, ez;

        float gx=data[1], gy=data[0], gz=-data[2], ax=data[3], ay=data[4],az=data[5];
        
        
        //eliminate bad data:

        if (ax==0 && ay==0 && az==0){
          //Serial.println("Accelerometer bad data");
          return;
        }

    // normalise the measurements

    norm = sqrt(ax*ax + ay*ay + az*az);
    ax = ax / norm;
    ay = ay / norm;
    az = az / norm;

    // estimated direction of gravity
    vx = 2*(q1*q3 - q0*q2);
    vy = 2*(q0*q1 + q2*q3);
    vz = q0*q0 - q1*q1 - q2*q2 + q3*q3;
        
    // error is sum of cross product between reference direction of field and direction measured by sensor
    ex = (ay*vz - az*vy);
    ey = (az*vx - ax*vz);
    ez = (ax*vy - ay*vx);


    // integral error scaled integral gain
    exInt = exInt + ex*Ki;
    eyInt = eyInt + ey*Ki;
    ezInt = ezInt + ez*Ki;

    // adjusted gyroscope measurements
    gx = gx + Kp*ex + exInt;
    gy = gy + Kp*ey + eyInt;
    gz = gz + Kp*ez + ezInt;
        
    // integrate quaternion rate and normalise
    q0 = q0 + (-q1*gx - q2*gy - q3*gz)*halfT;
    q1 = q1 + (q0*gx + q2*gz - q3*gy)*halfT;
    q2 = q2 + (q0*gy - q1*gz + q3*gx)*halfT;
    q3 = q3 + (q0*gz + q1*gy - q2*gx)*halfT;  

    // normalise quaternion

    norm = sqrt(q0*q0 + q1*q1 + q2*q2 + q3*q3);
    q0 = q0 / norm;
    q1 = q1 / norm;
    q2 = q2 / norm;
    q3 = q3 / norm;

}

questo codice si esegue in 500 microsecondi, e il grosso è portato via dalle radici quadrate (sqrt). Anche sin, cos e altre funzioni trigonometriche sono lente. notare che le operazioni sono tutte a float, quindi non ottimizzate per arduino