Si tratta di una manifestazione che si tiene in Olanda e che prevede la partecipazione di numerosi team che si sfidano nella realizzazione di trabiccoli eolici, insomma delle ventomobili! Ricordo che qualche mese fa un amico mi chiedeva se aveva senso immaginare di piazzare una turbina sul tettuccio di una automobile per generare corrente elettrica per alimentare l’autovettura stessa. Risposi che era una palese violazione del principio di conservazione dell’energia, infatti la potenza inviata alle ruote era la stessa che “generava” il flusso d’aria che metteva in moto la turbina sul tetto, ma che al netto dei rendimenti la potenza sviluppata diventava insufficiente a muovere l’auto stessa.

Qui la faccenda è diversa: infatti il vento è previsto e presente a priori. Inoltre, causa attriti e rendimenti, la quota parte di potenza della vena fluida che diventa potenza utile è molto limitata, e di conseguenza la velocità del trabiccolo molto bassa. Peraltro la velocità che si raggiunge sarà quella di equilibrio (delle potenze), per via del fatto che alla velocità del vento reale va a sommarsi quello “virtuale” dovuto al moto del trabiccolo contro vento. Insomma, una bella sfida ingegneristica, guarda caso sponsorizzata dai big dell’eolico che non si lasciano certo sfuggire l’occasione di un po’ di visibilità e di ottenere ingegneri entusiasti già un po’ formati sul campo!

Al minuto 0:23 anche un trabiccolo alimentato da una turbina ad asse verticale!

VAWT at Racing Aeolus

Qui invece i dettagli del regolamento.

Beh, buona visione!

Dear Alberto and Benedetta

How are you all.

Sorry for missing my contact for a long time. In fact it was to be like it was. I did not know what to tell you since there was no a new report besides that the pump was not working. So now I am telling you that the pump is working. remember this was the result of long time struggle. This is the third pump to use and now things are good. I will send you a video report to prove this.

Thank you I wish to here from you soon

Suha

Insomma: il sistema adesso funziona stabilmente! il progetto, la prima parte almeno, è finito!

Grazie, per ora semplicemente grazie!

A chi ci ha sostenuto

a chi ci ha aiutato economicamente

a chi ha lavorato con noi.

E, soprattutto, grazie mr. Suha per aver perseverato in questi mesi!

Siamo orgogliosi di aver lavorato fianco a fianco!

Ora…ora parte la fase due: arrivederci ad agosto 2012, mr Suha!

As you can read in the above email from mr. Suha, things have come to an end: the wind pump works, and works good!

we are so happy

and we want to thank all those people

who helped us with money

who joined us

who worked with us.

But, mostly, we want to thank mr. Suha for his tenacity and patience during these months!

We are proud for all that work we did together with you!

So, let’s start with phase two now: see you on summer 2012, mr. Suha!

Maggiori informazioni anche semplicemente su wikipedia.
Peraltro, per non realizzare ex-novo le pale stesse e i profili, abbiamo pensato per ora di applicare semplicemente una piccola sagoma alle due basi, come si vede in figura, ancora una volta realizzati per il tramite di Vectorealism:

La versione definitiva prevede già fin d’ora l’integrazione delle alette nella sagoma stessa.

In order to improve turbine efficency we added two winglets to each blade, one on each side, just like windgenkits and vawts.net.

PASWAT says:

Winglets will create a small increase in the lift to drag ratio, and that will create a small increase in the overall energy conversion. Most of the energy conversion for conventional VAWT occurs on the upwind pass of the blades (about 80%). So if the winglet extends inward from the blade, it will have the most effect. A winglet extending outward from the blade must be considered from the perspective of added drag when upwind versus less tip vortex losses when downwind.

This improvement aims to reduce vortex, blade tip losses: it should be around 2-3%. Obviously we need to test this.
As you can see in the above images, we simply added a thin shape to the external airfoils, just to mantain the previous ones and reduce costs. The final version will include the winglets directly in the whole structure.

In una giornata particolarmente ventosa, venerdì 20 gennaio, abbiamo pensato di sfruttare l’occasione e misurare dati più realistici, avendo a che fare con vento “vero” a terra dell’ordine di 3-4 m/s, più che sufficienti per avviare la nostra piccola turbina. Purtroppo abbiamo avuto la dabbenaggine di non fissare il VentolINO al suolo, con conseguente rovinosa caduta della torretta e della turbina quando girava, più o meno, a 200 giri/min… caspita, un disastro! Il weekend è trascorso perciò nella riparazione del danno (oltre all’esternazione di colorite espressioni ) e nella nuova acquisizione di pochi dati, ancora con turbina priva di carico.

Ebbene, ancora non siamo ai risultati attesi: ci aspetteremmo valori di λ intorno a 1,4 – 1,5 , invece otteniamo poco più di 1,0. Eppure stiamo lavorando in similitudine geometrica e fluidodinamica con il VentolONE big!

Abbiamo avuto modo di notare, tra le altre cose, come il fissaggio delle pale sia particolarmente arduo, anzi, di fatto impossibile nella configurazione attuale: già a 100 giri/min queste subiscono una accelerazione centrifuga del centro di massa (posto, a circa 45mm dal perno di fissaggio) pari 2,6 g (circa 26 m/s²), che non è uno scherzo! Facile immaginare quello che poi accade nella realtà, cioè una “apertura” delle pale che, a lungo andare, tende a frenare la turbina stessa e a far scendere λ intorno a 0,75. Effettivamente non abbiamo pensato di misurare l’angolo di attacco dopo pochi giri, per vedere se lo spostamento è immediato, il che giustificherebbe il valore ridotto di λ. Rimedieremo!

Conclusioni parziali: accidenti, queste pale vanno fissate in qualche maniera! magari anche drastica (un ulteriore perno), pur di poter sviluppare test accurati e raggiungere l’obiettivo di definire i parametri ottimali per il nostro VentolINO.

Inoltre: l’apertura delle pale suggerisce un possibile sistema per la frenatura dinamica della turbina: come da figura che segue, si potrebbe immaginare un sistema a molla, con molla non lineare, che intervenga solamente oltre un certo numero di giri: da pensare!

(image from an unknown turbine report)

—

As anyone can see in the above images we are getting on with tests. Unfortunately a wind gust dropped the VentolINO turbine down, so it took all the weekend to repair the damage: damn!

So we have some new data, but always lower than what we expected: since we works in geometric and fluid dynamics similarity, λ should reach a 1,4 – 1,5 value, like past summer. We noticed blades always pitch from 9 degrees outside, and than turbine comes to a smooth stop. So this could be the reason: it depends if it happens immediately, already at a low RPM. If so, a possible solution could be to add another one pin to prevent pitching.

This could also be a possible way to dynamically to slow down turbine RPM, may be with a non linear spring, just like the above image.

Sistemare il VentolINO su una pedana nel cassone del pickup non è stato particolarmente arduo, e nemmeno sistemare sensori e la postazione di acquisizione a bordo macchina.

Se da un lato infatti abbiamo raggiunto velocità di rotazione decisamente sostenute per una struttura tutto sommato semplice e realizzata in materiale plastico, con un picco di 480 giri/min, per contro l’analisi del rapporto di velocità lambda ci ha riservato una doccia fredda:

Insomma, ci aspettavamo un valore di lambda pari a 1,5, come nel modello in scala 1:1. E invece…

Pensa e ripensa, riteniamo che il posizionamento relativo di anemometro e carrozzeria e di VentolINO e carrozzeria generi una discrepanza nei dati.

Settaggi: si noti la posizione dell’anemometro rispetto alla vettura -take a look to the anemometer position!

La velocità del vento vista dalla turbina è probabilmente inferiore a quella vista dall’anemometro, la quale è probabilmente superiore a quella effettiva dell’automobile (di questo ci siamo effettivamente accorti in fase di acquisizione, imputando il fatto alla scarsa precisione del tachimetro dell’autovettura…).

Abbiamo perciò provato a simulare numericamente come varierebbe la curva caratteristica nel caso si assuma come velocità effettiva l’80% di quella misurata, ottenendo i dati in verde sopra riportati, decisamente più in linea con le aspettative.

C’è tuttavia un’altra possibilità: l’influenza delle turbolenze, che per un modellino in scala con similitudine fluidodinamica non perfetta possono assumere valori tali da inficiare le prestazioni.

Ci auguriamo di tratti solo di turbolenze sull’anemometro, e che la turbina abbia le prestazioni attese: per verificarlo ci basterà posizionarlo meglio, vicino e in linea con la turbina, per ottenere conferma o smentita delle ipotesi.

—

We are getting on with tests on the turbine. Unfortunately first results are not as good as we expected, since turbine efficiency and speed factory are really lower than our bigger model.

As you can see in the upper graph, yellow dots are the ones coming from real data, speed factor around 1.00: bad! Green dots mean are virtual ones, coming from a numerical reduction to 80% of wind speed measured with the anemometer: these could be good!

The reason: as you can see in the above images, anemometer should be hardly disturbed by air turbulence coming from the car, and so the turbine, with higher speed for anemometer and lower one for turbine. If so, the turbine is under a lower energy current, so the bad results could be explained.

To verify this idea, we will mount the anemometer in front of the turbine, hoping to find a lower speed…and good performances for the turbine!

vortex datalogger

Per completezza riportiamo anche il listato: in sostanza si utilizzano due interrupt e una scheda SD e si incrementano i relativi contatori associati. il codice è molto grezzo e migliorabile, i suggerimenti sono i benvenuti!

reed sensor: how it works

Waiting for testing the VentolINO turbine (tomorrow) this is the electric scheme with the sensors we use for measuring wind speed and turbine angular speed: we used these sensors this summer, too, and in Jambiani, and they works well. We just added a reed sensor instead of optoswitch to lower the power consuption and to be able to use a simple battery as power line for Arduino. Following the code, too: it is quite rough, but it works! Suggestions are welcomed!

// update: 11 gen 2012
#include <SD.h>
#include <Wire.h>
#include “RTClib.h”
// A simple data logger for the Arduino analog pins
// how many milliseconds between grabbing data and logging it. 1000 ms is once a second
#define LOG_INTERVAL  10000 // mills between entries (reduce to take more/faster data)
// how many milliseconds before writing the logged data permanently to disk
// set it to the LOG_INTERVAL to write each time (safest)
// set it to 10*LOG_INTERVAL to write all data every 10 datareads, you could lose up to
// the last 10 reads if power is lost but it uses less power and is much faster!
#define SYNC_INTERVAL 10000 // mills between calls to flush() – to write data to the card  ***
uint32_t syncTime = 0; // time of last sync()

#define ECHO_TO_SERIAL   1 // echo data to serial port
#define WAIT_TO_START    0 // Wait for serial input in setup()

// the digital pins that connect to the LEDs
//- #define redLEDpin 2
//- #define greenLEDpin 3

// The analog pins that connect to the sensors
//- #define photocellPin 0           // analog 0
//- #define tempPin 1                // analog 1
//- #define BANDGAPREF 14            // special indicator that we want to measure the bandgap
//int ledPin = 13;                // il LED emettitore del sensore di presenza della stampante (sensore a forcella)   ***
                                  //  è collegato al pin 13 (senza resistenza, perchè l’uscita 13 è già limitata in corrente)
//int statusPin = 12;             // il LED di stato è connesso al pin 12: cambia stato on/off a ogni passaggio delle linguette dell’albero della turbina
double rpmcount;  // rpmcount tiene conto dei passaggi delle linguette attraverso il sensore di posizione, per calcolare la velocità angolare della turbina
double rpmpass;  // rpmpass è la variabile in cui si parcheggia il valore di rpmcount, quando si calcola la velocità angolare rpm (intanto la turbina continua a girare…!)
double rpm;  // rpm è il valore della velocità angolare calcolata a partire da rpmcount –> rpmpass, in giri/min
double omega;  // rpm è il valore della velocità angolare, in rad/sec
//volatile int status;  ***
double count;  // count tiene conto dei passaggi sul sensore reed dentro l’anemometro Vortex, e serve a calcolare la velocità del vento
double pass;  // pass è la variabile in cui si parcheggia il valore di count, quando si calcola la velocità del vento (intanto l’anemometro continua a girare…!)
unsigned long timePrevious;  // istante dell’ultimo polling di misura
unsigned long duration;  // tempo trascorso dall’ultimo polling di misura
double interval=LOG_INTERVAL;  // intervallo di polling
float windSpeed = 0;

//- #define aref_voltage 3.3         // we tie 3.3V to ARef and measure it with a multimeter!
//- #define bandgap_voltage 1.1      // this is not super guaranteed but its not -too- off

RTC_DS1307 RTC; // define the Real Time Clock object

// for the data logging shield, we use digital pin 10 for the SD cs line
const int chipSelect = 10;

// the logging file
File logfile;

void error(char *str)
{
  Serial.print(“error: “);
  Serial.println(str);

  // red LED indicates error
//-  digitalWrite(redLEDpin, HIGH);

  while(1);
}

void setup(void)
{
  Serial.begin(9600);

#if WAIT_TO_START
  Serial.println(“Type any character to start”);
  while (!Serial.available());
#endif //WAIT_TO_START

  // initialize the SD card
  Serial.print(“Initializing SD card…”);
  // make sure that the default chip select pin is set to
  // output, even if you don’t use it:
  pinMode(10, OUTPUT);

  // see if the card is present and can be initialized:
  if (!SD.begin(chipSelect)) {
    error(“Card failed, or not present”);
  }
  Serial.println(“card initialized.”);

  // create a new file
  char filename[] = “LOGGER00.CSV”;
  for (uint8_t i = 0; i < 100; i++) {
    filename[6] = i/10 + ’0′;
    filename[7] = i%10 + ’0′;
    if (! SD.exists(filename)) {
      // only open a new file if it doesn’t exist
      logfile = SD.open(filename, FILE_WRITE);
      break;  // leave the loop!
    }
  }

  if (! logfile) {
    error(“couldnt create file”);
  }

  Serial.print(“Logging to: “);
  Serial.println(filename);

  // connect to RTC
  Wire.begin(); 
  if (!RTC.begin()) {
    logfile.println(“RTC failed”);
#if ECHO_TO_SERIAL
    Serial.println(“RTC failed”);
#endif  //ECHO_TO_SERIAL
  }
  logfile.println(“millis,datetime,delta_t,n_Vortex,numero_di_passaggi”);  
#if ECHO_TO_SERIAL
  Serial.println(“millis,datetime,delta_t,n_Vortex,numero_di_passaggi”);
#endif //ECHO_TO_SERIAL

  // If you want to set the aref to something other than 5v
//  analogReference(EXTERNAL);

 duration = 0;
  count = 0;
  timePrevious = 0;
  rpmcount = 0;
  rpm = 0;

  attachInterrupt(1, arduino_anemometer, FALLING);  // l’interrupt dell’anemometro è collegato al pin 1, attraverso la function arduino_anemometer
  attachInterrupt(0, rpm_fun, FALLING);  // l’interrupt del sensore a forcella è collegato al pin 0, attraverso la function rpm_fun    ***

  //pinMode(ledPin, OUTPUT);  // pone in uscita il pin dell’emettitore del sensore a forcella  ***
  //digitalWrite(ledPin, HIGH);  // accende l’emettitore del sensore a forcella  ***

  //pinMode(statusPin, OUTPUT);    // pone in uscita il pin del LED di stato  *** 
  //status = LOW;  ***
  //digitalWrite(statusPin, status);  ***

  // use debugging LEDs
  //- pinMode(redLEDpin, OUTPUT);
  //- pinMode(greenLEDpin, OUTPUT);
}

void loop(void)
{
  DateTime now;
  duration = (millis() – timePrevious);
  if (duration >= interval) {
//
//  // delay for the amount of time we want between readings
//  delay((LOG_INTERVAL -1) – (millis() % LOG_INTERVAL));

  //- digitalWrite(greenLEDpin, HIGH);

  // log milliseconds since starting
  uint32_t m = millis();
  logfile.print(m);           // milliseconds since start
  logfile.print(“, “);   
#if ECHO_TO_SERIAL
  Serial.print(m);         // milliseconds since start
  Serial.print(“,”); 
#endif

  // fetch the time
  now = RTC.now();
  // log time
  logfile.print(‘”‘);
  logfile.print(now.year(), DEC);
  logfile.print(“/”);
  logfile.print(now.month(), DEC);
  logfile.print(“/”);
  logfile.print(now.day(), DEC);
  logfile.print(” “);
  logfile.print(now.hour(), DEC);
  logfile.print(“:”);
  logfile.print(now.minute(), DEC);
  logfile.print(“:”);
  logfile.print(now.second(), DEC);
  logfile.print(‘”‘);
#if ECHO_TO_SERIAL
  Serial.print(‘”‘);
  Serial.print(now.year(), DEC);
  Serial.print(“/”);
  Serial.print(now.month(), DEC);
  Serial.print(“/”);
  Serial.print(now.day(), DEC);
  Serial.print(‘ ‘);
  Serial.print(now.hour(), DEC);
  Serial.print(“:”);
  Serial.print(now.minute(), DEC);
  Serial.print(“:”);
  Serial.print(now.second(), DEC);
  Serial.print(‘”‘);
#endif //ECHO_TO_SERIAL

    pass=count;  // salva il valore presente di count in pass
    rpmpass=rpmcount;  // salva il valore presente di rpmcount in rpmpass
    duration = (millis() – timePrevious);  // calcola il tempo trascorso
    timePrevious = millis();  // aggiorna timePrevious all’istante presente
    windSpeed = (pass/(duration/1000)*2.5);  // calcola la velocità del vento a partire dal numero di passaggi, dal tempo trascorso, con il coefficiente 2,5 (vedi Vortex + Caleb), in mph
    rpm = (rpmpass/4)/(duration/1000)*60;  // calcola la velocità angolare della turbina, tenendo conto di 4 linguette sull’albero, in giri/min
    omega=2*3.1416*rpmpass/duration*1000;  // converte la velocità angolare in rad/sec
#if ECHO_TO_SERIAL
    Serial.print(“,    “);
    Serial.print(duration);
    Serial.print(“,    “);
    Serial.print(pass);
    Serial.print(“,    “);
    //Serial.println(rpmpass);
    Serial.print(rpmpass);
    Serial.print(“,  -  “);
    Serial.print(windSpeed);
    Serial.print(“,    “);
    Serial.println(rpm);
    #endif //ECHO_TO_SERIAL
// azzera i contatori di misura
    count = 0;
    rpmcount = 0; 

    logfile.print(“, “);
    logfile.print(duration);
    logfile.print(“, “);
    logfile.print(pass);
    logfile.print(“, “);  
    logfile.println(rpmpass);

  // Now we write data to disk! Don’t sync too often – requires 2048 bytes of I/O to SD card
  // which uses a bunch of power and takes time
  if ((millis() – syncTime) < SYNC_INTERVAL) return;
  syncTime = millis();

  // blink LED to show we are syncing data to the card & updating FAT!
  //- digitalWrite(redLEDpin, HIGH);
  logfile.flush();
  //- digitalWrite(redLEDpin, LOW);

  }
  }
void arduino_anemometer()
{
  count++;
//if (status == LOW) {  // a ogni passaggio inverte lo stato del LED di stato, on/off
//    status = HIGH;
//  }
//  else {
//    status = LOW;
//  }
//digitalWrite(statusPin, status);
}

void rpm_fun()
{
  rpmcount++;  // incrementa il numero di passaggi delle linguette attraverso il sensore a forcella
//  if (status == LOW) {  // a ogni passaggio inverte lo stato del LED di stato, on/off
//    status = HIGH;
//  }
//  else {
//    status = LOW;
//  }
//  digitalWrite(statusPin, status);
}

Abbiamo lavorato sodo, in questi giorni, per realizzare il primo VentolINO!
Modello in scala 1:5 del VentolONE di Jambiani, ci consentirà di sperimentare tutto lo sperimentabile, con poca fatica: profili alari diversi, angoli di attacco delle pale, posizione del punto di attacco, capacità di auto-avvio. Potremo inoltre portarlo agevolmente in giro per mostre e fiere.

Inoltre contiamo di collegarci a breve un piccolo generatore di corrente, sì da renderlo un oggetto che ha anche una utilità energetica oltre che scientifica. A quel punto sarà pronto per essere anche messo in vendita, per sperimentatori e appassionati!

Un grazie sentitissimo a Vectorealism per la collaborazione nella realizzazione delle parti in acrilico che costituiscono la turbina! La possibilità di avere pezzi su misura, senza costi fissi nè di magazzino, rendono la loro attività una manna e una grande opportunità per tutti, sperimentatori e hobbyisti!

—

We worked hard these days to build our first VentolINO (italian word for “small VentolONE”). It is a 1:5 scale model of Jambiani VentolONE, and we will use it to test anything we want, with a good ease: different blade airfoils, angle of attack, point of attack for the blades, self-start capability.

We aim to link a small generator, so that VentolINO could be energetically useful (ok, not so much power, this is clear!). And then we will sell it, hoping hobbyists and testers will like it so much!

p.s.: abbiamo un sacco di cose da raccontarvi, di novità…e una nuova mail da mr. Suha con buone notizie! Ma ora…godiamoci il Natale!

Peraltro nemmeno la Valsugana è una località particolarmente adatta all’eolico, a parte forse qualche passo e qualche altopiano: peccato!

Nell’ambito del discorso relativo ai prodotti commerciali americani segnaliamo anche questo, proveniente dal Missouri, e in vendita per circa 2000$, per una potenza nominale dichiarata di 500W, quindi 4$ / Watt: è inutile, gli americani in queste cose hanno una marcia in più!

Sul loro sito non compaiono le specifiche, se non le dimensioni, pari a 4feet X 3feet = 1,2m X 0,95m.
Ora, se la matematica non ci inganna, per produrre 500W con un rendimento plausibile di 0,35 occorre un vento superiore a 13 m/s…ci sembra un po’ tantino… !