Anemometer and sensors logging, 2: build a single-board computer

Following lines are for those who doesn’t now so much about linux distros, single-board computer, terminal, shell, installations. For sure an IT guy will find them a bit simplistic, but the target is our African friends and whoever just want to start. So please, be patient with my IT mistakes!

Ok, it’s time to start to build a place where I can put my data.

Allright, the cloud is a great thing, encryption is a great resource but…I prefer to have my data. At least, every time I want / I need my data to be only mine.

I know and I’ve been using some nice IoT platforms able to store data: Xively, Thingspeak, Carriots, just to say about. They are good, works well the way I will try to explain I did, but sometimes you need to pay, sometimes you have limited data plans, sometimes you may think “where the hell are my data?”

So I decided to have a personal server. I’m a mechanical engineer, I started few years ago to study about these themes, it requires time and a bit of skills.

What I was looking for was a cheap computer able to collect data and serve them whenever I needed. And, for sure, I wanted a low power computer. 10 years ago this was difficult to find for a non-IT worker.

Things changed with Raspberry Pi. I never bought one, but I feel grateful to Raspberry foundation because of their effort. In a few years a lot of single-board computers grew up, and now you can choose between UDOO, Raspberry, Banana Pi, Orange Pi, etc.

SoC computers

I bought (ok, I funded…) a Cubieboard three years ago. A great piece of hardware, with a growing communities (here the most interesting) which aided me a lot to understand how to move around with installations.

After many installations, re-installations, usually concerning Debian or Ubuntu, I finally landed on Armbian.

logo_v4

Igor Pečovnik , the owner of the website, is a great guy from Slovenia who is building distros for many different single-board computer platforms, have a look here. I don’t know why he is doing this, if there’s a business model or is just for fun, but his work is really great.

So now I’m using Armbian on my Cubieboard A10, a Debian Wheezy version you can download here. There are two versions, “legacy” and “vanilla”, the key difference is which kernel is used: legacy uses an older and stable one, vanilla lies on a newer one, even up to the newest one.

I tried both ones: vanilla doesn’t seem to work well with my webcams (yes, I will show you how to use webcams too), so I decided for legacy.

Installation is not difficult. After downloading the preferred distro, extract the image file: in the archive you will find some files, and a .raw file such as Armbian_5.00_Cubieboard_Debian_jessie_3.4.110.raw

This file has to be flashed on an microSD card.

If you use Windows, ok, shame on you: I can’t help you nothing more then telling you to use the imagewriter.exe file inside the archive, hoping you will decide to cure your Windows-mania…

If you use a Linux distro, well, it is simple: open a terminal, move to the folder containing the .raw file, then just write

dd bs=1M if=filename.raw of=/dev/sdx

as root user, where /dev/sdx is SD card device. Or, which is the same:

sudo dd bs=1M if=Armbian_5.00_Cubieboard_Debian_jessie_3.4.110.raw of=/dev/mmcblk0

Be careful: usually /dev/sda is your system folder, /dev/sdb your home directory, using these you will destroy your system!
Usually SD card are identified by /dev/mmcblk0, depending on the system you are using.

It will take some minutes to complete flash process. Then unmount if mounted, extract, insert in microSD card slot on Cubieboard, connect a monitor and turn on. Better if Ethernet is connected and Internet available for immediate updates.

After a few minutes login prompt will appear: on first boot only root user is present, and password is 1234, you are requested to change it.

Then you can create your personal user, with

adduser user1

(user1 is an example username).
Then you need to insert your user in the sudo group, to have access to some SuperUser functionality:

usermod -aG sudo user1

The system is ready, now!
Ok, there’s no desktop environment neither desktop manager, by now; it is better/simpler to install one.
To install XFCE and LightDM type:

apt-get -y install xorg lightdm xfce4 tango-icon-theme gnome-icon-theme

To install MATE and LightDM:

apt-get -y install xorg lightdm mate-desktop-environment mate-desktop-environment-extras tango-icon-theme gnome-icon-theme pluma

Whatever was your choice, at the end of the installation it is time to reboot PC, so:

reboot

After reboot you will have a login screen: get in with your username and password, the system is on!

Maybe now you would like to disconnect the monitor, in order to leave it alone, just as low power companion on your desk. Ok, you can access and control it without any monitor, simply you need to install a VNC client on your computer (I use Vinagre on Ubuntu, many others are available) and a VNC server on the Cubieboard.

So open a terminal on Cubieboard (nice: for some minutes you need to connect your monitor again!) and write

sudo apt-get install x11vnc

Now, since x11vnc server will start only after login, you need to activate autologin. After a look here (or here, italian version) it is clear you have to modify lightdm.conf.

In a terminal:

sudo pluma /etc/lightdm/lightdm.conf

find the following lines inside it

[SeatDefaults]
#autologin-user=
#autologin-user-timeout=0

and uncomment them, then change to

[SeatDefaults]
autologin-user=user1
autologin-user-timeout=0

Save and exit terminal, then reboot. You should get in automatically.

Now open menu, system, preferences, startup applications (on MATE; on XFCE maybe it is a little different)

 

x11vnc-startup

and add (inside “command”)

x11vnc -forever

Save and exit.

Now open your browser, access to your router and change settings in order to permit communication between your Cubieboard and your PC: this means you have to open port 5900, the one used by VNC communications.

While dealing with router, have a look to IP address assigned to your Cubieboard, i.e. 192.168.1.5: you will need to now to access Cubieboard.

forwarding

Then open your VNC client on your PC, type Cubieboard address (i.e.: 192.168.1.5:5900) and enjoy your single-board computer.

Next ride: we will install a web server and a database to store data.

(to be continued…)

Annunci

Anemometer and sensors logging, 1

I’m starting here a few articles about our experiences in datalogging wind data and generic sensor data.
Since the VentolONE team origins, before everythings started, I knew the first thing you need to know concerning wind turbines is how much wind is available, and which kind: constant, gusts, etc.

In early days in 2006 I didn’t know so much about microcontrollers: I had just a few knowledge in electronics coming from my master degree in mechanical engineering. Not so much, really.

After some tries with some friends of mine I understood I had to build by myself a datalogging system, the way I wanted it to be:

  • open-source (code)
  • open-hardware (where possible)
  • simple, everyone could build it
  • reliable, not a funny joke
  • able to send data from wherever to wherever
  • customizable

Now I can say: here we are!

As far as you know, VentolONE team had some trouble with its start-up, founded and closed in one year, without producing nothing more than disappointment and quarrels.
Well, during that period I did something, keeping on my interest in datalogging data from Africa.
Following the attemps with Arduino Yun (may 2014) I tried new ways, cheaper and promising.

Now it is time to write it down where I finally came!

EmonCMS and datalogging

(to be continued…)

MiniMakerFaire Torino

…insomma, dopo il successo a PopupMakers del mese di marzo siamo stati piacevolmente assaliti dalle nuove possibilità che ne sono conseguite e abbiamo decisamente trascurato un po’ il blog: incontri, richieste, possibilità, in Italia, a Zanzibar, negli USA. Ogni tanto ci accorgiamo di quanto impreparati siamo di fronte a queste piccole grandi possibilità!

Per intanto, scade stasera la Call for Makers della MiniMakerFaire Torino che si terrà a Torino il 31 maggio: una maker faire cittadina e da strada, sulla falsariga di quelle ben più famose americane come quella di San Mateo.

Siccome ci abbiamo preso gusto a Roma…ci proviamo! Vorremmo raccontare di un piccolo grande progetto che è nato insieme e parallelo al VentolONE ormai 7-8 anni fa, cioè la possibilità di acquisire dati di vento a distanza e con spesa molto limitata. Il percorso è stato difficile e tortuoso, con tentativi vari che han portato nel 2011 a realizzare la prima stazione di datalogging basata su Arduino. Utilizzata per la prima volta a Zanzibar, ci ha consentito di avere tanti dati per Ukomola prima, per Mfereke dopo, dove tuttora sta lavorando indefessa dopo l’installazione della scorsa estate 2013. Nel corso del tempo migliorie su migliorie si sono susseguite, riducendo drasticamente i consumi, migliorando il sistema di acquisizione, migliorando la procedura di scrittura sulla scheda SD.

Restava, finora, la relativa impossibilità di evitare il passaggio attraverso la scheda SD che necessita di una persona la quale di tanto in tanto si rechi sul posto, salvi i dati e ce li spedisca via mail: se il sito è in una zona impervia (vedi Ukomola), se la connessione Internet è ballerina, se il processo di copiatura non va a buon fine, ecco, settimane di dati rischiano di andare perse in un attimo.

Come già pensammo fin dall’inizio servirebbe che i dati venissero salvati in locale, su una scheda SD perchè non si sa mai, ma soprattutto questi venissero spediti periodicamente direttamente a un server, meglio se personale, in modo che nessuno possa metterci il becco (soprattutto quei curiosoni di Google, Yahoo!, Microsoft, Facebook e sopratutto l’NSA…!). L’uso di una GSM shield per Arduino si è rivelato un po’ macchinoso e abbastanza costoso.

Poi è arrivato Arduino Yun. Una rivoluzione. Una scheda Arduino (Arduino Leonardo, per la precisione) unita ad una mini-distribuzione Linux pensata per l’hacking di alcuni router, OpenWRT, con porta ethernet e scheda wifi integrate. Arduino + Linux, interfacciati tra loro con una libreria sritta ad hoc, e wifi o ethernet già implementati significa aprire delle praterie di possibilità di utilizzo, con la possibilità di “far parlare” tutto con tutto! Quindi anche il nostro anemometro. Con un prezzo assolutamente abbordabile, € 52 + IVA sullo store ufficiale (si tenga conto che una scheda Arduino con il datalogger di Adafruit costano, insieme, sostanzialmente la stessa cifra)

In ultimo: la presenza di una porta USB host a bordo ci ha fatto pensare…vuoi vedere che la si può utilizzare sia per salvare i dati su una pendrive, più comoda di una scheda SD, sia, più succulento, per connettere Yun alla rete 3G-UMTS, quindi a Internet anche dove non c’è nè wifi nè rete LAN?

Detto…fatto! Abbiamo trovato una libreria già bella pronta su GitHub (https://github.com/pictux/Yun_3g), e la stiamo testando e modificando alla bisogna.

VentolONE and Arduino Yun, at Maker Faire Torino 2014

VentolONE and Arduino Yun, at Maker Faire Torino 2014

Per intanto la nostra Arduino Yun sta monitorando una serra, trasmette i dati via wifi a un home server realizzato con una Cubieboard, li salva inoltre su una scheda microSD e li pubblica su un sito web: appena la connessione 3G sarà attivata sposteremo Yun sul VentolONE italico, per monitorarlo continuativamente (qui il feed):

Arduino Yun working with Xively for testing

Arduino Yun working with Xively for testing

In ultimo, un gruppo di amici ha sviluppato per noi una applicazione web per l’analisi dei dati anemometrici: una bomba! Che racconteremo più avanti, per non dilungarci oltre, qui.

Ma contiamo di spiegare tutto questo, e tutte le potenzialità, durante la Mini Maker Faire a Torino, a fine maggio: speriamo di esserci!

Rieccoci! – Here we are again!

Dopo oltre un mese di assenza rieccoci sul blog!

Stiamo litigando di brutto con gli anemometri, ecco tutto! Semplicemente, nei giorni grigi di febbraio e marzo non si riusciva a caricare a sufficienza le batterie per garantire il ciclo giornaliero completo.

I conti non tornano: la batteria è una Li-Po da 1400mAh, ipotizzando una scarica fino a 1000mAh per preservare la batteria stessa si dovrebbe ottenere una durata di circa 20h, dal momento che il consumo è pari a 52mA (misurati). E invece…al più 15 ore, come da figura.

Poco male: il pannello dovrebbe caricare…e invece…in condizioni nebulose tipiche del nostro febbraio che si possono tranquillamente riscontrare a Njombe ad agosto non si riesce a far fronte alla ricarica. Nemmeno passando a potenza doppia (da 2W a 4W).

Ovviamente abbiamo tenuto conto dei valori di insolazione e di specifici fattori di nuvolosità: nulla, non se ne esce. O i pannelli rendono meno del previsto, o il fattore di nuvolosità è troppo ottimistico.

Qui, per intanto, qualche dato fotovoltaico africano.

Probabilmente ci risolveremo a utilizzare batterie AGM al piombo, con regolatore di carica: tipo questo kit. Peccato, il solar shield integrato con Arduino farebbe un sacco figo!

Li-Po battery discharge curve

Here we are again! A month passed from our last post, but we had a lot of stuff with our anemometers. They work well, it is the recharging system that is going to make me mad!

It is simple, just like described in many and many sites: 1400mAh Li-Po batteries, an Arduino solar shield and a solar panel. Nice, it seemed, but it simply doesn’t work! With foggy days that you can find in Njombe in August a 2W panel is not enough to recharge the battery, neither 2W + 2W panels do! It seems to me …puzzling!

Ok: obviously we took care of photovoltaic power data and considered a reasonable cloud factor.
Here some data, hoping to find a solution quickly…

Anemometro e Arduino, aggiornamento – Anemometer and Arduino, upgrade

Ormai l’avrete capito, siamo appassionati di questa microcontrollore che tante possibilità ci ha aperto senza necessità di competenze estreme in ambito elettronico e informatico.

Insomma, dovendo spedire in Tanzania un paio di nuovi anemometri per valutare le potenzialità di altrettanti siti ci siamo posti il problema di migliorare e affinare quanto già detto qui e in generale qui.

Sostanzialmente abbiamo aggiornato il file di confronto, cercando di limare tutto quel che si poteva in termini di spesa. La soluzione ottimale, come si può vedere dal file aggiornato nel foglio dec 2012 è quella che comprende componenti comprati tutti da cooking-hacks: accettando una spedizione via posta, che richiede più tempo, si riesce a scendere fino a circa 160€ per un sistema completo. Per ora, dato l’out-of-stock di uno componenti, ci adegueremo a una soluzione italiana che costerà circa 169€.

anemometer and Arduino, december 2012 update

anemometer and Arduino, december 2012 update

Il nuovo sistema prevede l’utilizzo di un anemometro fornito dalla torinese Deltatronic, avente un sensore a effetto Hall in luogo del sensore Reed che qualche problema di bouncing del segnale generava: in  questo caso invece a un costo inferiore otteniamo un segnale molto più pulito, già pronto all’uso. Purtroppo ad ora il nuovo anemometro è acquistabile solamente direttamente in sede.

Siamo un po’ lontani dal 100€ auspicato all’inizio di tutta l’avventura: va detto tuttavia che siamo anche ben lontani anche dalle cifre che si possono trovare online per soluzioni professionali come PowerPredictor. Queste spesso non lasciano spazio di intervento alcuno, addirittura obbligano l’utente a utilizzare software proprietari per l’analisi dei dati acquisiti (così poi magari la ditta fornitrice può costruirci su un po’ di mappe e un po’ di marketing dei dati eolici…;-) ).
Nel nostro caso invece i dati vengono salvati in formato CSV, leggibili e analizzabili comodamente con un semplice foglio di calcolo (o magari con il software che 3 intrepidi ragazzi del varesotto e dintorni si sono offerti di implementarci, rigorosamente open!).

Viste le cifre in ballo stiamo pensando alla possibilità di commercializzare il kit anemometrico, così da poter ricavare qualcosina per i nostri progetti, e parallelamente diffondere un po’ di cultura energetica. Che ne dite?

So here we are again talking about that smart microcontroller which simplified so much our work!

Since we need 2 more anemometers to install in Tanzania for more wind data, we did an upgrade to the system, in order to improve performances and, ok, to lower costs.

Now you can see the best solution in a comparison chart,(upgraded, see sheet dec 2012): cooking-hacks is the cheapest one.
We also changed anemometer: the present is a Deltatronic one, which uses a Hall effect sensor. this is a better solution compared to the previous one, with a bouncing Reed sensor.

Now the final cost is around 170€: we think this is good enough, since other commercial solutions cost more and more (from 300€ to…infinite!) and the user usually can’t act freely with collected data, but have to use proprietary software to view and analize. We prefer, as usual, an open solution: so we save data in CSV files and work with simple datasheet software (by now: a dedicated software is coming).

So, we are thinking about a commercial version in order to diffuse energy culture and have some money for our projects: what do you think about?

Nuovi dati da Ukomola – New data from Tanzania

Tarcisio ci ha spedito nuovi dati anemometrici, qualche giorno di tempo per l’elaborazione e la riflessione e…giudicate voi!

I dati di marzo – aprile:

Ukomola, 15t of March to 15 of April

e quelli di aprile – maggio:

Ukomola, 15t of April to 16 of May

Insomma, per farla breve: si è passati da una velocità media di 1,69 m/s (poco, poco vento) a 2,9 m/s (non eccelso), con una distribuzione continua lungo tutta la giornata in una maniera che ha dell’incredibile: insomma, c’è sempre vento, notte e giorno!

Ora, è molto probabile che incidano anche la vegetazione e la posizione in cui è installato l’anemometro, cosa che verificheremo quando giungeremo là.

Per certo si può dire, ora, che il vento è sufficiente già così al compito che ci è stato proposto: 3,3 kWh al giorno elettrici estraibili consentono di alimentare i bisogni della scuola, almeno per ora. In loco poi potremo migliorare e vedere se una opportuna localizzazione delle turbine possa aumentare l’energia recuperabile, per intanto ci godiamo il netto miglioramento e, particolare non da poco, il buon funzionamento del nostro sistema anemometrico!

——-

New wind data from Ukomola! These are far away better than previous ones, so that it is clear we will be able to power the school with 2 VentolONE turbines, as we aim to do!

As you can see in the above images, average speed raised to 2,9 m/s from 1,69 m/s, and, expecially, there is wind all day, every our of the day!

Probably better data could be found with a better location for the anemometer: we will verify this when we will be there. By now we are sure to that 3,3 kWh a day are available for the school!

And the anemometer is working fine…this is a great satisfaction for us, too!

Primi dati anemometrici da Ukomola – First wind data from Ukomola

Sono arrivate via mail le rilevazioni anemometriche “reali!”! Tarcisio ce le ha fornite con l’aiuto di Maurizio Buffoli che ringraziamo sentitamente, anche per le foto che seguono relative al sito dell’installazione estiva. Poi ci abbiamo lavorato un po’, e di seguito vi riportiamo i primi risultati parziali.

Tarcisio raising the anemometer

Da questi primi dati per la verità non emerge nulla che già non sapessimo, cioè che marzo-aprile è il periodo con minor intensità eolica nella zona, considerazioni che avevamo già in precedenza estrapolato da vari siti dai quali è possibile risalire a valori medi giornalieri.

makambako: wind speed in first week of April

Al solito, la media giornaliera non è granchè dal punto di vista di una corretta valutazione della producibilità eolica, dal momento che la potenza estraibile dal vento cresce con il cubo della velocità del vento stesso, quindi, con un esempio banale:

sito A: 2+2+2+2=8, media=2, producibilità= 2^3 + 2^3 + 2^3 + 2^3 = 32

sito B: 0+4+4+0=8, media=2, producibilità= 0^3 + 4^3 + 4^3 + 0^3 = 128

sito C: 0+0+8+0=8, media=2, producibilità= 0^3 + 0^3 + 8^3 + 0^3 = 512

emerge come sia più utile avere poche ore di vento sostenuto piuttosto che un vento debole costante, a parità di velocità media.

Volendo fare comunque riferimento alla velocità media di un sito è necessario introdurre il coeeficiente di irregolarità o fluttuazione kf, estrapolabile e calcolabile dai dati reali, ottenendo

calcolando kf come rapporto tra la velocità media cubica (radice cubica della media dei cubi) e la velocità media.

Insomma, dai dati emerge un valore di kf pari a 1,42 circa, che significa, in buona sostanza, che il vento è molto irregolare e che rispetto al calcolo con la velocità media la potenza reale è superiore del 280% (1,42^3).

La velocità media è tuttavia, come detto, molto bassa, come atteso: 1,55 m/s, cioè più o meno 5,6 km/h.

Ad oggi, dai calcoli di Andrea, sarebbero comunque estraibili circa 10 kWh/giorno con le turbine che andremo ad installare (beninteso, al lordo dei rendimenti elettrici!), che non è poco per un mese poco ventoso!

In sostanza: se il coefficiente di irregolarità che dipende solo dal sito si manterrà su questi livelli anche nelle prossime acquisizioni, sapendo che la velocità media cresce negli altri mesi dell’anno, troveremo ulteriore conferma della bontà del progetto che stiamo mettendo in atto!

Seguono alcune fotografie che il buon Maurizio ci ha girato: diciamo la verità, da queste non riusciamo bene a capire se, al di là della vegetazione che si vede nelle immediate vicinanze, il terreno sia mediamente sgombro o invece immerso nella boscaglia.

the site, 1

the site, 2

Ci aspettavamo invece qualcosa di simile alle foto rinvenute su un sito che racconta di don Tarcisio, delle quali riportiamo un campione (le foto sono coperte da copyright, speriamo di non far nulla di male riportandola qui, riconoscendone l’attribuzione a Marilisa Alberoni):

not so far from Ukomola

Vedremo se riusciremo ad ottenere nuove fotografie, o qualche indicazione in più da don Tarcisio!

——

Finally first wind data from Ukomola are available! We analized and found what we expected to find: March is not the best period to extract power from wind!

As you can find in the spreadsheet, mean speed is under 2 m/s. But, extremely important, fluctuation coefficient (also know as irregularity coefficient) is above 1,4, so this site is probably good enough as we expected.

Some photos give us a quick look to the site where wind towers will be built: ok, it seems so many trees are all around, but, maybe, it is due to the point of view only! We hope so, more investigations will come!

average wind speed in Ukomola, March 2012

Anemometro, Arduino e 100 possibilità – Arduino, anemometer and possibilities

Abbiamo spedito a don Tarcisio una piccola stazione anemometrica del tutto analoga a quella che stiamo utilizzando per le nostre rilevazioni. Da quando abbiamo cominciato (4 anni fa!) parecchie cose sono cambiate nell’ambito dell’elettronica digitale e dei microcontrollori, in particolare abbiamo visto crescere a dismisura l’utilizzo di schede tipo Arduino, alla quale in special modo ci siamo appassionati data la natura open del progetto stesso.

Ora, nel momento di scegliere quale componentistica utilizzare per l’anemometro da spedire in Tanzania, nell’ottica di realizzare uno strumento solido e facile da utilizzare che non preveda particolari abilità tecniche e viva di vita propria abbiamo analizzato alcune possibili soluzioni e abbiamo pensato di condividerle.

A onor del vero la soluzione che abbiamo fin qui utilizzato presenta un (grave) vizio di fondo che farà inorridire gli elettronici più smaliziati: un po’ per la fretta (si partiva a giorni), un po’ per ignoranza, un po’ perchè di fatto utilizziamo quasi sempre l’alimentazione da rete elettrica, non abbiamo inserito un regolatore di tensione tra pannello solare e batteria.

anemometer data logging: the wrong way

Lo schema necessario è invece quanto segue:

anemometer data logging: the right way

Come si vede la differenza risiede sostanzialmente nella presenza di un regolatore di tensione che rileva l’avvenuta ricarica della batteria e disattiva il collegamento con il pannello, preservando la batteria stessa dal sovraccarico.

Si è trattato pertanto di scegliere la soluzione più semplice ed economica per rilevare i dati di vento a Ukomola dove andremo a installare 2 turbine eoliche.

Nel seguito quindi le nostre elucubrazioni e considerazioni. Nella anemometer – comparison chart potete trovate la tabella comparativa con tutti i link ai rivenditori, in modo che possiate andare direttamente ai negozi online.

Da notare che i prezzi di spedizione son in alcuni casi solamente stimati, e che i prezzi riportati fanno riferimento al 20 febbraio 2012.

Abbiamo analizzato i seguenti casi:

  • Soluzione 1: ri-adattamento del logger attualmente in uso, con aggiunta di un regolatore di carica
  • Soluzione 2: cooking hacks (libelium), con pannello acquistato a parte
  • Soluzione 3: cooking hacks con pannello incluso
  • Soluzione 4: seeedstudio, con shield apposito per Arduino
  • Soluzione 5: Kit Starter Plus 5W

(continua…)

Anemometro e datalogger – datalogger and anemometer

In attesa di cominciare le sperimentazioni (domani) riportiamo di seguito lo schema elettrico dei sensori utilizzati per la misurazione della velocità del vento e della velocità di rotazione della turbina, sensori peraltro già utilizzati questa estate e poi a Jambiani. Abbiamo previsto la possibilità di sfruttare un sensore reed (recuperato da un tachimetro da bicicletta) in luogo di un optoswitch (recuperato da una stampante) per limitare il consumo di corrente e permetterci di collegare l’alimentazione della scheda Arduino a una semplice batteria, ricaricata da un pannellino solare (in fututo, perchè no, dalla turbina stessa).

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!

vortex anemometer

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);
}