Seconda Prova Elettronica 2018: Traccia e Soluzione Completa

📄 Traccia della seconda prova

La prova riguarda la caratterizzazione dinamica di un solaio in cemento armato sottoposto a una deformazione iniziale mediante un pistone idraulico. Dopo il rilascio devono essere misurate le vibrazioni della struttura.

🧠 1. Analisi della traccia

Il sistema deve eseguire automaticamente una prova dinamica sul solaio. Sono presenti:

• un pulsante di START;
• un pistone idraulico;
• una pompa elettrica;
• un’elettrovalvola di rilascio;
• un avvisatore luminoso;
• un avvisatore acustico;
• cinque sensori di deformazione.

Un sensore è collocato vicino al pistone e viene utilizzato anche durante la fase di caricamento. Gli altri quattro sono posizionati agli angoli del solaio.

Sequenza richiesta

1. Premendo START inizia un preallarme ottico e acustico della durata di 2 minuti.
2. Durante il preallarme viene generato un impulso ogni 1 secondo.
3. Terminato il preallarme viene attivata la pompa.
4. Durante la salita del pistone la frequenza delle segnalazioni raddoppia: 2 Hz.
5. La deformazione centrale viene continuamente misurata.
6. Quando viene raggiunta la deformazione massima impostata, la pompa viene fermata.
7. L’elettrovalvola viene aperta e il solaio viene liberato istantaneamente.
8. Inizia l’acquisizione simultanea delle deformazioni dei cinque punti.
9. La prova termina quando l’ampiezza della vibrazione centrale è inferiore all’1% della deformazione iniziale.

🔗 2. Schema a blocchi

Sistema programmabile scelto

Per una soluzione didattica possiamo utilizzare una scheda Arduino Mega, che dispone di un numero sufficiente di ingressi analogici e digitali.

⏱️ 3. Scelta della frequenza di campionamento

La traccia specifica che la massima frequenza di vibrazione significativa del solaio è:

Per il teorema di Nyquist-Shannon la frequenza di campionamento deve essere almeno doppia:

30 Hz rappresenta però soltanto il limite teorico minimo. Per ottenere una descrizione temporale migliore scegliamo:

L’intervallo tra due campionamenti diventa:

Filtro anti-aliasing

Prima della conversione A/D inseriamo su ciascun canale un filtro passa-basso.

Poiché il segnale utile arriva fino a circa 15 Hz, possiamo scegliere una frequenza di taglio nell’ordine di:

In questo modo vengono attenuate le componenti ad alta frequenza che potrebbero produrre aliasing.

Campionamento simultaneo

I cinque punti del solaio devono essere confrontati nello stesso istante. Leggere A0, A1, A2, A3 e A4 uno dopo l’altro introduce inevitabilmente un piccolo ritardo temporale.

Una soluzione didattica consiste nell’utilizzare cinque circuiti Sample & Hold pilotati contemporaneamente.

Tutti i Sample & Hold congelano contemporaneamente il valore. Arduino può quindi convertire i cinque canali in sequenza senza perdere l’informazione relativa allo stesso istante fisico.

📏 4. Interfaccia dei sensori estensimetrici

La traccia indica un segnale differenziale proporzionale alla deformazione con escursione massima di 24 V.

Arduino non può ricevere direttamente questa tensione, quindi è necessario un circuito di condizionamento.

Amplificatore differenziale

Possiamo utilizzare un amplificatore differenziale dimensionato in modo che:

Il rapporto richiesto è:

Per un amplificatore differenziale vale:

Una possibile scelta teorica è:

ottenendo:

Protezione ingresso ADC

A valle del condizionamento è opportuno prevedere:

• resistenza serie;
• limitazione della tensione;
• protezione contro sovratensioni;
• filtro anti-aliasing;
• Sample & Hold.

⚡ 5. Interfaccia di pompa, elettrovalvola e avvisatori

Pompa

La pompa è un carico di potenza e non può essere comandata direttamente dal microcontrollore.

Arduino pilota quindi:

Per un motore di potenza reale è preferibile che il relè piloti la bobina di un contattore, dimensionato in funzione della corrente della pompa.

Elettrovalvola

Anche l’elettrovalvola viene gestita come dispositivo ON/OFF:

Avvisatori

Il sistema utilizza:

• un segnalatore luminoso;
• una sirena o avvisatore acustico.

Durante la fase iniziale gli impulsi vengono generati a 1 Hz, mentre durante la prova passano a 2 Hz.

🔄 6. Algoritmo di gestione

💻 7. Codice Arduino completo

Il seguente programma implementa una possibile soluzione didattica. La soglia di deformazione massima deve essere determinata dopo la calibrazione del sistema.

// =========================================================
// SECONDA PROVA ELETTRONICA 2018
// Prova dinamica impulsiva su solaio
// Soluzione didattica con Arduino Mega
// =========================================================

// -------------------------
// PIN DIGITALI
// -------------------------

const byte PIN_START   = 2;
const byte PIN_HOLD    = 3;

const byte PIN_LUCE    = 6;
const byte PIN_SIRENA  = 7;

const byte PIN_POMPA   = 8;
const byte PIN_VALVOLA = 9;


// -------------------------
// SENSORI
// -------------------------

const byte SENSORI[5] = {
  A0, A1, A2, A3, A4
};

// sensore centrale = A0
const byte SENSORE_CENTRALE = 0;


// -------------------------
// PARAMETRI
// -------------------------

// 200 Hz
const unsigned long PERIODO_CAMPIONE_US = 5000;

// 2 minuti
const unsigned long PREALLARME_MS = 120000UL;

// soglia massima da calibrare
const int SOGLIA_DEFORMAZIONE = 800;

// valori acquisiti
int valori[5];

// riferimento del solaio a riposo
int zeroSensore[5];

// deformazione massima effettivamente raggiunta
int deformazioneIniziale = 0;


// =========================================================
// SETUP
// =========================================================

void setup() {

  Serial.begin(115200);

  pinMode(PIN_START, INPUT_PULLUP);

  pinMode(PIN_HOLD, OUTPUT);

  pinMode(PIN_LUCE, OUTPUT);
  pinMode(PIN_SIRENA, OUTPUT);

  pinMode(PIN_POMPA, OUTPUT);
  pinMode(PIN_VALVOLA, OUTPUT);

  digitalWrite(PIN_POMPA, LOW);
  digitalWrite(PIN_VALVOLA, LOW);

  digitalWrite(PIN_LUCE, LOW);
  digitalWrite(PIN_SIRENA, LOW);

  Serial.println("Sistema pronto");

  calibraZero();
}


// =========================================================
// LOOP
// =========================================================

void loop() {

  // INPUT_PULLUP:
  // pulsante premuto = LOW

  if (digitalRead(PIN_START) == LOW) {

    delay(30);

    if (digitalRead(PIN_START) == LOW) {

      eseguiProva();

      while (digitalRead(PIN_START) == LOW) {
        delay(10);
      }
    }
  }
}


// =========================================================
// CALIBRAZIONE ZERO
// =========================================================

void calibraZero() {

  long somma[5] = {0,0,0,0,0};

  const int campioni = 100;

  for (int n = 0; n < campioni; n++) {

    acquisisciSensori();

    for (byte i = 0; i < 5; i++) {
      somma[i] += valori[i];
    }

    delay(5);
  }

  for (byte i = 0; i < 5; i++) {

    zeroSensore[i] =
      somma[i] / campioni;
  }

  Serial.println("Calibrazione completata");
}


// =========================================================
// ESECUZIONE PROVA
// =========================================================

void eseguiProva() {

  Serial.println("INIZIO PROVA");

  // -----------------------------------------
  // 1. PREALLARME - 2 minuti - 1 Hz
  // -----------------------------------------

  unsigned long inizio = millis();

  while (millis() - inizio < PREALLARME_MS) {

    digitalWrite(PIN_LUCE, HIGH);
    digitalWrite(PIN_SIRENA, HIGH);

    delay(200);

    digitalWrite(PIN_LUCE, LOW);
    digitalWrite(PIN_SIRENA, LOW);

    delay(800);
  }


  // -----------------------------------------
  // 2. AZIONAMENTO POMPA
  // -----------------------------------------

  digitalWrite(PIN_POMPA, HIGH);

  Serial.println("Pompa ON");

  int deformazione = 0;

  unsigned long ultimoLampeggio = 0;
  bool statoAllarme = false;


  // -----------------------------------------
  // 3. CARICAMENTO SOLAIO
  // -----------------------------------------

  while (deformazione < SOGLIA_DEFORMAZIONE) {

    acquisisciSensori();

    deformazione =
      abs(valori[SENSORE_CENTRALE] -
          zeroSensore[SENSORE_CENTRALE]);


    // segnalazione 2 Hz
    if (millis() - ultimoLampeggio >= 250) {

      ultimoLampeggio = millis();

      statoAllarme = !statoAllarme;

      digitalWrite(PIN_LUCE, statoAllarme);
      digitalWrite(PIN_SIRENA, statoAllarme);
    }
  }


  // memorizza deformazione iniziale
  deformazioneIniziale = deformazione;


  // -----------------------------------------
  // 4. DEFORMAZIONE MASSIMA
  // -----------------------------------------

  digitalWrite(PIN_POMPA, LOW);

  Serial.println("Pompa OFF");


  // -----------------------------------------
  // 5. RILASCIO ISTANTANEO
  // -----------------------------------------

  digitalWrite(PIN_VALVOLA, HIGH);

  Serial.println("Elettrovalvola ON");
  Serial.println("Rilascio solaio");


  // -----------------------------------------
  // 6. ACQUISIZIONE VIBRAZIONI
  // -----------------------------------------

  acquisizioneVibrazioni();


  // -----------------------------------------
  // 7. FINE PROVA
  // -----------------------------------------

  digitalWrite(PIN_VALVOLA, LOW);

  digitalWrite(PIN_LUCE, LOW);
  digitalWrite(PIN_SIRENA, LOW);

  Serial.println("FINE PROVA");
}


// =========================================================
// ACQUISIZIONE VIBRAZIONI
// =========================================================

void acquisizioneVibrazioni() {

  unsigned long prossimoCampione = micros();

  unsigned long inizioFinestra = millis();

  unsigned long ultimoLampeggio = millis();

  bool statoAllarme = false;

  // soglia 1%
  int sogliaFine =
    max(1, deformazioneIniziale / 100);

  // massimo rilevato in una finestra
  // di 1 secondo
  int massimoFinestra = 0;

  while (true) {

    // ---------------------------------
    // campionamento ogni 5 ms
    // ---------------------------------

    if ((long)(micros() - prossimoCampione) >= 0) {

      prossimoCampione +=
        PERIODO_CAMPIONE_US;

      acquisisciSensori();

      int deformazioneCentro =
        abs(valori[0] - zeroSensore[0]);

      if (deformazioneCentro > massimoFinestra) {
        massimoFinestra = deformazioneCentro;
      }


      // ---------------------------------
      // invio dati CSV
      // ---------------------------------

      Serial.print(millis());

      for (byte i = 0; i < 5; i++) {

        Serial.print(",");
        Serial.print(valori[i]);
      }

      Serial.println();
    }


    // ---------------------------------
    // segnalazione 2 Hz
    // ---------------------------------

    if (millis() - ultimoLampeggio >= 250) {

      ultimoLampeggio = millis();

      statoAllarme = !statoAllarme;

      digitalWrite(PIN_LUCE, statoAllarme);
      digitalWrite(PIN_SIRENA, statoAllarme);
    }


    // ---------------------------------
    // controllo inviluppo ogni secondo
    // ---------------------------------

    if (millis() - inizioFinestra >= 1000) {

      Serial.print("Ampiezza finestra: ");
      Serial.println(massimoFinestra);

      if (massimoFinestra < sogliaFine) {

        break;
      }

      massimoFinestra = 0;
      inizioFinestra = millis();
    }
  }
}


// =========================================================
// ACQUISIZIONE DEI CINQUE SENSORI
// =========================================================

void acquisisciSensori() {

  // -----------------------------------------
  // Comando comune dei Sample & Hold
  // -----------------------------------------

  digitalWrite(PIN_HOLD, HIGH);

  delayMicroseconds(10);

  digitalWrite(PIN_HOLD, LOW);


  // -----------------------------------------
  // Lettura dei valori memorizzati
  // -----------------------------------------

  for (byte i = 0; i < 5; i++) {

    valori[i] =
      analogRead(SENSORI[i]);
  }
}

📝 8. Seconda parte – Quesiti

La prova richiede lo svolgimento di due quesiti tra i quattro proposti. Per completezza li analizziamo tutti.

🎓 Conclusioni

Questa prova mette insieme molti degli argomenti fondamentali dell’elettronica applicata:

• trasduttori estensimetrici;
• condizionamento analogico;
• campionamento;
• conversione A/D;
• filtri anti-aliasing;
• controllo degli attuatori;
• programmazione di sistemi automatici.

La parte più importante non è il singolo sketch Arduino, ma il corretto dimensionamento dell’intera catena: