Tecnicamente's Weblog

Just another WordPress.com weblog

Olympus OMD E-M10 e download foto via WiFi

Da qualche tempo sto smanettando con la mia Olympus OMD E-M10 e sono moltro soddisfatto, una macchina fotografica veramente ben fatta ma una cosa mi ha  sconcertato…

La macchina è dotata di WiFi e senza informarmi più di tanto ho dato per scontato che tale WiFi di certo si potesse usare per scaricare le foto scattate dalla fotocamera al computer, senza quindi scomodarsi ad estrarre la SD o a collegare cavetti tra computer e fotocamera, mi sbagliavo.

Olympus da a disposizione delle applicazioni per Android e IOS che permetto di gestire la fotocamere di scattere foto usando il cellulare o altro dispositivo mobile e ovviamente di scaricare le foto, non è previsto nulla per il computer!!!

Quindi la scelta obbligata è quella di usare un dispositivo mobile e poi da quello archiare su un cloud. Soluzione che a me non piace e non interessa.

Bene la sfida è stata accettata, cosa posso fare per averla vinta?

USARE PYTHON🙂

Ebbene sì è passato poco tempo dal mio entusiasmo per questo linguaggio e poco tempo effettivamente ad esso dedicato ma alla fine mi ha permesso di fare cose che diversamente non avrei potuto.

Dopo aver visto che è possibile accedere via browser alla fotocamera ho usato le librerie urllib e urllib2 che python mette a disposizione e scritto pochissime righe di codice per poter tramite un semplice comando da terminale scaricare le foto.

Con piccole modifiche credo funzioni anche sul altre fotocamere con sistema similare, ho quindo fatto una prototipazione rapida dell’idea che trovate qui: https://github.com/tecnicamente/OlympusSync/blob/master/OlympusSync.py

Il passo successivo è renderlo un programmino serio e chissà forse una bella interfaccia grafica.

Per ora funziona anche se a dire il vero noto una certa lentezza nel download ma non ho chiaro il perchè.

Per chi è interessato alla fotocamera in questione suggerisco questa lettura: http://www.saggiamente.com/2015/03/27/recensione-olympus-om-d-e-m10-la-botte-piccola-con-grande-vino/

Buone foto🙂

 

 

Python, finalmente si comincia

Ho passato qualche ora e leggere tutorial vari di introduzione al linguaggio e a seguire dei corsi su YouTube, una idea di base me la sono fatta, ho provato a fare le esercitazioni del corso universitario trovato su YouTube, ma non posso aspettare molto, ho poco tempo libero😦, quindi come fare per imparare più velocemente?

Semplice basta trovare un progetto per applicare quanto capito e cercare di espande la conoscenza acquisita.

Preparatevi:

  1. Aprire il browser con aperta una finestra su python.it ed una su google.com in modo da avere disponibile tutta la documentazione immaginabile;
  2. Scaricare l’editor di testo preferito, io sull’apple store per OSX ho trovato TextWrangler, editor veramente ben fatto e gratis
  3. Pensavo di dover installare Python ma magia… è già presente su OSX
  4. Aperto uno schermo virtuale e sistemato l’editor e due shell in modo da avere, una zona dove scrivere il software, una zona dove lanciare quanto scritto e una zona dove fare test direttamente in shell python o lanciare l’help per leggere la documentazione, questo è il mio ambiente:screenshot

Completata la descrizione degli strumenti passiamo alla descrizione del progetto.

Per monitorare la velocità di connessione di casa uso un app sul mio cellulare, sto parlando del famoso speedtest di Ookla.

L’app permette di ricevere un file in formato testo con tutti i dati delle misurazioni fatte. Nel mio caso dopo dei valori molto buoni di velocità in download mi sono trovato una riduzione, lo scopo che mi sono prefisso è analizzare con attenzione i dati, ma i dati sono organizzati in un modo poco pratico per essere presi ed analizzati direttamente su un foglio di calcolo, quindi perché non trattarli opportunamente con un programmi in python?

Tutti i campi dei dati salvati sono racchiusi tra due  virgolette e separati da una virgola, cosi: “…….”,”…….”,…. .

Scopo della prima parte del progetto è aprire il file originale e salvare i dati su un secondo file dove i campi sono separati da tabulazione.

Il codice Python è estremamente compatto:

# -*- coding: utf-8 -*- 
""" 
Created on Sun Feb 7 14:17:13 2016 
""" 
import sys, os, string 

#controllo dei parametri passati 
if len(sys.argv) <3: 
    print "Uso: ", sys.argv[0], "file-dati-da-leggere file-dati-da-produrre-in-uscita" 
    sys.exit(2) 
# creo il file contenente i dati in uscita 
OutputFile = open(sys.argv[2],"w") 
if not os.path.isfile(sys.argv[1]): 
    print "Controllare il percorso o nome del file: ", sys.argv[1] 
    sys.exit(2) 
# Apertura del file passato come parametro 
InputFile = open(sys.argv[1],"r") 
for Riga in InputFile: 
    RigaElaborata = Riga.replace('","',"\t") 
    RigaElaborata = RigaElaborata.replace('"','\t') 
    OutputFile.write(RigaElaborata)  
InputFile.close() 
OutputFile.close()

Ridare vita ad un Acer Aspire ONE A110B e scoprire Sakis3g

Nel post di questa sera mi pacerebbe parlare della mia esperienza di “resurrezione” fatta con un simpatico Acer Aspire ONE zg5, per capirci questo qui nella versione 110B.

La versione più sfigata che poteva esserci, non fatevi trarre in inganno dallo storage SSD, è proprio lo storage a rendere lentissimo il computer.

OK mi è stato regalato, allora quale migliore ragione per non smanettarci su?🙂

l’OS precedente era compromesso quindi decido di installarci sopra la distribuzione che dopo Debian ha preso il mio cuore… Ubuntu, installo la 14.04 LTS.

Non vi annoio su come installarla, in giro trovate documentazioni serie e ben fatte. Vi posso dire che l’installazione è stata semplice e senza particolari problemi, tutti i device del dispositivo funzionano correttamente.

Comincio quindi ad usarlo per le solite cose, leggere un giornale, le email, guardare qualche filmato su youtube.

Il computerino lavora discretamente ma ogni volta che c’e’ una scrittura su disco SI PIANTA.

Provo ad allegerire UNITY, interfaccia che ho imparato ad apprezzare, ma scopro che non esiste piu’ la versione 2D ad effetti ridotti!!!!!

Bene, usare il netbook in queste condizioni non è possibile, occore essere radicali. Installo cosi FVWM, il window manager che usavo anni fa, ed il sistema è diventato utilizzabile. In un attimo di euforia ho provato ad avere un ambiente un pelino più desktop ed ho installato XFCE.

Il risultato è che con FVWM il sistema è molto reattivo e pulito, a me piace e credo che manterrò tale configurazione, anzi sto pensando a questo punto di passare a Debian per poter alleggerire al massimo🙂.

XFCE installato con un bel “sudo apt-get install xubuntu-desktop” è ancora molto usabile e devo dire che come ambiente desktop ha tutto quello che serve.

Ad un certo punto ho dovuto però fare i conti con il mio essere “borghese“, da tempo ho smesso di configurare il sistema usando i file in /etc e di ricompilare il kernel per ottimizzare al massimo, da anni installo Ubuntu “così come è”, “visto e piaciuto”, e via.

Tutto ad un tratto mi sono accorto che non riuscivo ad usare ma mia chiavetta 3G per collegarmi ad internet!!! Il motivo? semplice l’applicativo per il collegamento è integrato in Unity e non disponibile per gli altri ambienti.

Provo ad usare il caro vecchio wvdial che usavo ai tempi di Debian con il modem a 33.6K, ma nulla da fare.

Cerco in rete e finalmente trovo Sakis3g. L’installazione è semplice:

  1. scaricate il file da http://www.sakis3g.com/#download
  2. scompattate il file con un bel: tar -xzvf sakis3g.tar.gz
  3. cambiate gli attibuti per rendere eseguibile: chmod +x sakis3g
  4. lanciate: ./sakis3g --interactive

Vi appariranno delle schermate per la configurazione, tenete a portata di mano l’APN del vostro gestore, nel mio caso mi indicava già tutto, ma non è detto che vada sempre bene.

Lanciato l’applicativo in pochi secondi sono stato in rete con il caro FVWM🙂

fvwm_acerone

Rilevatore EMF con Arduino

Avevo scritto l’articolo in inglese sperando di raggiungere un gruppo più ampio di persone, ma così non è stato, quindi lo ripropongo in Italiano.

In alcuni dei miei articoli ho descritto il mio piccolo progetto di un rilevatore EMF realizzato usando arduino, potete leggere qui, qui e qui.

Grazie a questo progetto ho avuto l’opportunità di analizzare alcune interessanti cose come:

  • La teoria delle antenne;
  • I filtri digitali;
  • l’uso della funzione millis() per emulare il multitasking;
  • La trasformata di Fourier.

I temi sono vasti ed interessanti, per ciò posso dire dire che il mio progetto non è veramente completo, ma mi ha dato molte tematiche da studiare e come risultato hanno aumentato la mia conoscenza.

Tornando al progetto posso sintetizzare la mia conclusione con la seguente frase: “TUTTI I PROGETTI DI RILEVATORI EMF CHE USANO SOLO ARDUNO CON UN CAVO ED UNA RESISTENZA COME ANTENNA SONO DELLE PRESE IN GIRO“.

Come prima cosa dovete sapere che non potete leggere o misurare direttamente il CAMPO MAGNETICO con uno strumento siffatto, parlo di arduini e un filo di rame, potete osservare solo le variazioni del CAMPO ELETTRICO, quindi quello che potete fare direttamente con il solo Arduino è osservare le variazione del campo elettrico nell’ambiente circostante.

In Italia la frequenza della rete elettrica è di 50 Hz, per tale motivo la mia aspettativa è quella di vedere le variazioni del campo elettrico in linea con tale frequenza, ma osservate il seguente grafico:

5ms

Nei grafici potete vedere il risultato delle misure con due diverse antenne, la conclusione è che l’antenna non è molto importante in termini della frequenza della variazione del segnale campo elettrico rilevato, altra cosa è che la frequeza di variazione è molto lontana dai circa 50 Hz attesi, molto strano. L’acquisisione è stata fatta con un campionamento di 200 Hz con lo scopo di evitare l’aliasing con il segnale da 50 Hz atteso.

Nei grafici successivi potete vedere i dati acquisiti vicino ad una lampada elettrica, la variazione del campo elettrico è misurata ma avviando l’analisi FFT non si vedono differeze su quelle che sono le frequenze del segnale, quindi la frequenza principale della variazione di campo elettrico è di circa 250 Hz come nell’esperienza precedente.

5ms-sorgente

La domanda è quale è la ragione della variazione del campo elettrico a 250 Hz? Caso interessante da investigare meglio.

Adesso vediamo cosa accade se passo da un campionamento da 200 Hz ad uno a 100 Hz.

Qui i risultati:

10ms

Ed adesso cosa accade se campiono a 50 Hz:

20ms

Ho usato diverse lunghezze di antenne e impedenze, ma l’unica cosa che sembra impattare in modo significativo sulla frequenza del campo elettromagnetico sembra essere la frequenza di campionamento.

Qui il codice usato, anche se un po’ grezzo:

#include <Arduino.h>
#define VERSIONE 4.01-27/10/2014
#define C 0.0048828125
#define T1 20
#define T2 60000

int flag = 0;

void waitForFlush(void){
/*******************************************
* scopo di questa funzione e non impegnare *
* la comunicazione seriale nei primi X *
* secondi. In tal modo il flush e sempre *
* facilmente realizzabile. *
*******************************************/
#define TIMETOWAIT 5000 /* ms */
unsigned long t0,t1;

t0 = millis();
t1 = millis();

while( t1-t0 < TIMETOWAIT){
   t1 = millis();
}
}
void setup(){
/*attivo la comunicazione seriale */
Serial.begin(57600);

/*do disponibilità a flush del controllore*/
waitForFlush();

/*Intezzazione del programma */
Serial.print("EMF DETECTOR V. ");
Serial.println(VERSIONE);
}
float valore, valore1;

void loop(void){
unsigned long t;

t = millis();
/* con t%10 campiono 100 volte al secondo, quindi a 100 Hz
con t%5 campiono 200 volte al secondo, quindi a 200 Hz
*/

if(t%T1 == 0){

valore = analogRead(A0)*C;
valore1 = analogRead(A5)*C;

/*
Serial.print(t);
Serial.print("\t");
*/

Serial.print(valore,5);
Serial.print("\t");
Serial.print(valore1,5);
Serial.println();
}
}

[AGGIORNAMENTO 9-Nov-2014]

Ho speso i giorni passati, per essere onesto le poche ore disponibili, investigando circa la sorgente del segnale e pensando a come applicare un filtro sull’acquisizione.

E’ stata una attività molto interessante ed ho aperto una nuova porta sui filtri digitali, imparando cose interessanti:

  1. I filtri passa-basso e passa-alto sono interessanti, ma richiedono molte risorse di calcolo, questo richiederebbe di programmare il mio arduino direttamente sull’ATMEL in C o ASSEMBLER, ma non sono sicuro dei risultati e sinceramente non ne ho voglia😉 ;
  2. Ci sono altri approcci più semplici per applicare un filtro:
    1. Utilizzare la media mobile;
    2. Utilizzare la media a finestra mobile.

Ho provato ad implementare entrambi i filtri, scusate il codice poco curato, lo migliorerò in una seconda vita😉

#include <Arduino.h>
#define VERSIONE "4.03-09/11/2014"

#define C 0.0048828125

#define T1 5
#define T2 60000

#define NCAMPIONI 10

//int flag = 0;

void waitForFlush(void){
/*******************************************
* scopo di questa funzione e non impegnare *
* la comunicazione seriale nei primi X *
* secondi. In tal modo il flush e sempre *
* facilmente realizzabile. *
*******************************************/
#define TIMETOWAIT 5000 /* ms */
unsigned long t0,t1;

t0 = millis();
t1 = millis();

while( t1-t0 < TIMETOWAIT){
   t1 = millis();
}
}

void setup(){

/*attivo la comunicazione seriale */
Serial.begin(57600);

/*do disponibilità a flush del controllore*/
waitForFlush();

/*Intestazione del programma */
Serial.print("EMF DETECTOR V. ");
Serial.println(VERSIONE);
}


float valore;
float campioni[NCAMPIONI];
float campioniSlideWindow[NCAMPIONI];

float somma=0;
float sommaSlideWindow=0;

float mediaMobile = 0;
float mediaSlideWindow = 0;

short int contatore = 0;
short int flag = 0;
short int i;

void loop(void){
unsigned long t;

t = millis();
/**********************************************************
 *con t%10 campiono 100 volte al secondo, quindi a 100 Hz *
 *con t%5 campiono 200 volte al secondo, quindi a 200 Hz  *
 *Applicano il fitro i campionamenti avvengono ogni 10*T  *
 *********************************************************/

if(t%T1 == 0){
  valore = analogRead(A0)*C;
  
  if (contatore < 10){
    campioni[contatore] = valore;
    //somma = somma + campione[contatore];
    contatore++;
  }


  
  if (contatore < NCAMPIONI && flag ==0){
    flag = 1;
    for (i=0; i<NCAMPIONI; i++){
      sommaSlideWindow = campioniSlideWindow[contatore]+sommaSlideWindow;
    }
    sommaSlideWindow = 0;
  }

  if (contatore < NCAMPIONI && flag !=0){
    campioniSlideWindow[contatore] = valore;
   
   for (i=0; i<NCAMPIONI; i++){     sommaSlideWindow = sommaSlideWindow + campioniSlideWindow[i];    }       mediaSlideWindow = sommaSlideWindow/NCAMPIONI;    sommaSlideWindow = 0;   }   if ( contatore >= NCAMPIONI){
      contatore =0;
      for (i=0; i<NCAMPIONI; i++){
         somma = somma + campioni[i];
      }
      mediaMobile = somma/NCAMPIONI;
      somma = 0;
  }
  

  Serial.print(t);
  Serial.print("\t");
  Serial.print(valore,5);
  Serial.print("\t");
  Serial.print(mediaMobile,5);
  Serial.print("\t");
  Serial.print(mediaSlideWindow,5);
  Serial.println();

}
}


Nei grafici seguenti i risultati dell’applicazione dei filtri.

Il filtro basato sulla media mobile sembra dare risultati migliori (seconda colonna).

20141106_5ms

dopo qualche minuto:

20141106_5mmms[AGGIORNAMENTO 14-Agosto-2015]

in merito alla tecnica di campionamento e conversione AD ho trovato due interessanti articoli della ATMEL

doc2559 e doc8003.

La teoria dell’oversampling è sicuramente cruciale per capire le misure fatte, cercando in rete ho trovato questo interessante articolo in italiano: http://www.mcmajan.com/mcmajanwpr/?p=2618

A presto con i risultati della sperimentazione.

Fortran95, il ciclo “DO” su matrici di grandi dimensioni

Se state usando il Fortran95 i motivi sono semplici, o vi stanno obbligando oppure volete usare un linguaggio di programmazione che non ha eguali nelle applicazioni del calcolo numerico ed in particolar modo nei calcoli dove si fa uso pesante di matrici.

Questo breve articolo ha due scopi:

  1. mostrare che bisogna organizzare le matrici nel modo migliore per permettere ai cicli di lettura di essere molto efficienti;
  2. mostrare le ottimizzazioni intrinseche del linguaggio e del compilatore;

Supponiamo di avere due matrici di grande dimensione la [A] e la [B], il calcolo che si vuole eseguire è c(i,j) = a(i,j) + b(i,j). Voglio trovare la matrice somma [C]=[A]+[B].

Operazione estremamente semplice, supponiamo ancora che decidiamo di usare il linguaggio C e che i dati siano interi, vediamo cosa accade usando il seguente codice:

#include<stdio.h>
#include<time.h>

#define X 10000
#define Y 10000

int main(void){
 int i, j;
 float t0, t1;
 //int a[X][Y], b[X][Y], c[X][Y];
 int **a, **b, **c;

/* allocazione della memoria */
 a = (int **)calloc(X,sizeof(int *));
 b = (int **)calloc(X,sizeof(int *));
 c = (int **)calloc(X,sizeof(int *));

 for(i=0;i<X;i++){
    a[i] = (int *)calloc(Y,sizeof(int));
    b[i] = (int *)calloc(Y,sizeof(int));
    c[i] = (int *)calloc(Y,sizeof(int));
 }

/* inizializzazione delle matrici */
 for(i=0;i<X;i++){
    for(j=0;j<Y;j++){
       a[i][j] = 1;
       b[i][j] = 2;
    }
 }
 
/* somma scorrendo per le colonne */
 t0 = clock();
 for(i=0;i<X;i++){
   for(j=0;j<Y;j++){
     c[i][j] = a[i][j] + b[i][j];
   }
 }
 
 t1 = clock();
 printf("%d\n",c[X-1][Y-1]);
 printf("tempo richiesto somme su colonne = %f\n",(double)(t1 - t0) / CLOCKS_PER_SEC);

/* somma scorrendo le righe */
 t0 = clock();
 for(j=0;j<Y;j++){
   for(i=0;i<X;i++){
     c[i][j] = a[i][j] + b[i][j];
   }
 }
 t1 = clock();
 printf("%d\n",c[X-1][Y-1]);
 printf("tempo richiesto somme su colonne = %f\n",(double)(t1 - t0) / CLOCKS_PER_SEC);

 return 0;
}

Il cui risultato sul mio povero PC è rappresentato nella seguente immagine:

C

Ok ma perchè ho messo un codice in C ed un test del risultato?

Ovviamente per mostrare come in Fortran95 sia comodo descrivere lo stesso algoritmo e per vedere quali sono i risultati in termini di tempo di accesso, quindi qui il codice:

program prova
implicit none
  integer :: i,j
  integer, parameter :: x=10000, y=10000
  real :: t0,t1
  integer, dimension(x,y) :: a,b,c

  a=1 ; b = 2

!SOMMA SCORRENDO LE COLONNE
  call cpu_time(t0)
  do i=1,x
    do j=1,y
      c(i,j) = a(i,j) + b(i,j)
    enddo
  enddo
  call cpu_time(t1)
  print*, c(x,y)
  print*, "tempo richiesto somme su colonne = ",t1-t0
  print*,""

!SOMMA SCORRENDO LE RIGHE
  do j=1,y
    do i=1,x
      c(i,j) = a(i,j) + b(i,j)
    enddo
  enddo
  call cpu_time(t1)
  print*, c(x,y)
  print*, "tempo richiesto somme su righe = ", t1-t0
  print*,""

!SOMMA IN MODO NATIVO DEL FORTRAN
  call cpu_time(t0)
  c=a+b
  call cpu_time(t1)
  print*, c(x,y)
  print*, "tempo richiesto somme tra matrici = ", t1-t0

end program prova

Con il seguente risultato:F

Come vedete la principale differenza tra i due linguaggi è che in Fortran le MATRICI ed i VETTORI sono tipi nativi, quindi è possibile fare delle operazioni direttamente su di esse.

Occorre tenere presente che ho usato i seguenti compilatori gcc e gfortran, quindi il backend è lo stesso, il perchè della differenza di risultato lo lascio agli esperti, io non so spiegarlo.

E’ interessante notare come una implementazione non oculata degli accessi agli array in C può essere disastrosa.

Tutti i modi usati in Fortran sono migliori, in particolare l’uso delle operazioni a livello “nativo” sulle matrici permette di ridurre notevolmente le righe di codice oltre al non trascurabile fatto avere tempi di calcolo migliori che in C.

Una interessante possibilità dei compilatori fortran è quella di parallelizzare il codice, cosa che purtroppo non riesco a testare😦.

 

Buon Coding in Fortran.

Articolo inutile sulla connettività mobile

Sono in aeroporto in attesa del mio volo, non avendo nulla da leggere armeggio con il mio cellulare, un bel cellulare da 5″.
Ad un tratto mi sento vecchio, ricordo i tempi in cui mi collegavo con un modem e giravo con modernissime chiavette USB e floppy disk.
Lavorare fuori casa era un incubo, dovevo trovare un PC con gli stessi programmi che usavo sul mio desktop a casa, ora sto seduto in un posto qualsiasi e con il cloud ho tutti i miei file a portata di mano,  posso usare applicativi remoti come google docs o app per Android come questa che sto usando per l’articolo sul blog, il tutto su un dispositivo tascabile molto più potente e versatile del mio primo PC con processore Pentium 166Mhz con estensioni MMX.
La tecnologia è uno spettacolo, ma sempre più spesso mi chiedo se tutti noi abbiamo
capito come usarla e non a subirla.

image

Google Drive su Ubuntu 14.04 LTS

Google drive è sicuramente uno strumento utile ed interessante, ci permette di avere i nostri archivi sempre a portata di mano, ma ad oggi non esiste un software ufficiale per Ubuntu e Linux in generale.

Come me molti usano più postazioni per lavorare, postazioni che possono avere anche differenze notevoli, ad esempio nel mio caso:

– Cellulare Android

– Portatile con Windows Vista

– Desktop con windows XP

– Portatile con Linux Ubuntu

Come tenere sincronizzatto tutto alla perfezione senza dover fare operazioni manuali su Ubuntu?

Semplice per tutte le architetture segnalate, tranne Ubuntu, sarà Google a fornivi il software.

Per Ubuntu occorre installare grive-tools.

Per installare procedete nel seguente modo:

Aggiungere il repository con il comando:

$ sudo add-apt-repository ppa:thefanclub/grive-tools

Aggiornare la lista dei pacchetti con il comando:

$ sudo apt-get update

Installare grive-tools con il comando:

$ sudo apt-get install grive-tools

A questo punto basterà lanciare “grive setup” dal pannello o “grive -a” da terminale e seguire le indicazioni.

Arduino and EMF detector

Usually I write my short note in italian, but I guess that sometime is better switch to english due to the fact that I can “improve” and I can reach more people in the web, so why do not start to write my post in english? (or better, I’m try to do that😉 ).

OK let’s go, in some of my previous post I described my little project around an EMF detector using arduino, please read this, this and this.

Thanks to this project I had the opportunity to investigate some interesting things like:

  • Theory of antenna;
  • Digital filters;
  • The use of millis() in order to emulate a multitasking on my Arduino Uno;
  • Fourier transform.

Very interesting topics, so I can say that my project isn’t completed, but it gave me a lot of points where I can study and enlarge my knoledge.

Coming to the project I can write a simple sentence that can summarize the result: “ALL EMF DETECTOR PROJECTS THAT USE ARDUINO, WIRES AND RESISTORS ARE BULLSHIT”

First of all you cannot read or measure MAGNETIC FIELS, but only ELECTRIC FIELDS, so what you can see directly whit you arduino is the variation of the electric field in the enviroment.

Here in Italy the frequency of the electric lines is 50Hz, so I guess that the variation of the EF is reletad to this frequency, but please look at next picture:

5msYou can see the measurement with different antennas, the results is that the antenna is not so importat about the frequency, and that the frequencies are quite far from 50Hz, very strange. I’m aquiring the data at 200Hz in order to avoid the aliasing with a signal of 50Hz.

In the next picture you can see the aquisition of data near to electric light, the variation of the EF is measured but there is no changes on the FFT analysis, so the main frequency of the field is  about 250 Hz as before

5ms-sorgente

The question is what is the reason for a EF at 250Hz? Nice to investigate.

Now what appen if I change the sample rate from 200Hz to 100Hz.

Here the result:

10ms

And now what I find at 50Hz of sample rate:

20ms

Someone can suggest howto detect the field at 50Hz?

I used different leght for antennas and impedence, but the only thing that seems focus on the EF frequency is the sample rate.
Here the code, very raw😉

#include <Arduino.h>
#define VERSIONE 4.01-27/10/2014
#define C 0.0048828125
#define T1 20
#define T2 60000

int flag = 0;

void waitForFlush(void){
/*******************************************
* scopo di questa funzione e non impegnare *
* la comunicazione seriale nei primi X *
* secondi. In tal modo il flush e sempre *
* facilmente realizzabile. *
*******************************************/
#define TIMETOWAIT 5000 /* ms */
unsigned long t0,t1;

t0 = millis();
t1 = millis();

while( t1-t0 < TIMETOWAIT){
   t1 = millis();
}
}
void setup(){
/*attivo la comunicazione seriale */
Serial.begin(57600);

/*do disponibilità a flush del controllore*/
waitForFlush();

/*Intezzazione del programma */
Serial.print("EMF DETECTOR V. ");
Serial.println(VERSIONE);
}
float valore, valore1;

void loop(void){
unsigned long t;

t = millis();
/* con t%10 campiono 100 volte al secondo, quindi a 100 Hz
con t%5 campiono 200 volte al secondo, quindi a 200 Hz
*/

if(t%T1 == 0){

valore = analogRead(A0)*C;
valore1 = analogRead(A5)*C;

/*
Serial.print(t);
Serial.print("\t");
*/

Serial.print(valore,5);
Serial.print("\t");
Serial.print(valore1,5);
Serial.println();
}
}

[UPDATE 9-Nov-2014]

I spent last days, to be honest the last free hours, investigating about the source of the signal and how to apply a filter.
So it was good, I opened a new door about digital filters and at the I discovered some important things:

  1. Low and High pass filters are interesting, but to much resource are necessary, due to this in mandatory leave the arduino IDE and use a pure C or Assembler approach to the controller, but I’m not sure about the results.
  2. There are others more simple approach to filter the input signal:
    1. moving average
    2. slide window average.

I tried to implement both, sorry for the dirty code, I will arrange it better in a second life😉

 

#include <Arduino.h>
#define VERSIONE "4.03-09/11/2014"

#define C 0.0048828125

#define T1 5
#define T2 60000

#define NCAMPIONI 10

//int flag = 0;

void waitForFlush(void){
/*******************************************
* scopo di questa funzione e non impegnare *
* la comunicazione seriale nei primi X *
* secondi. In tal modo il flush e sempre *
* facilmente realizzabile. *
*******************************************/
#define TIMETOWAIT 5000 /* ms */
unsigned long t0,t1;

t0 = millis();
t1 = millis();

while( t1-t0 < TIMETOWAIT){
   t1 = millis();
}
}

void setup(){

/*attivo la comunicazione seriale */
Serial.begin(57600);

/*do disponibilità a flush del controllore*/
waitForFlush();

/*Intestazione del programma */
Serial.print("EMF DETECTOR V. ");
Serial.println(VERSIONE);
}


float valore;
float campioni[NCAMPIONI];
float campioniSlideWindow[NCAMPIONI];

float somma=0;
float sommaSlideWindow=0;

float mediaMobile = 0;
float mediaSlideWindow = 0;

short int contatore = 0;
short int flag = 0;
short int i;

void loop(void){
unsigned long t;

t = millis();
/**********************************************************
 *con t%10 campiono 100 volte al secondo, quindi a 100 Hz *
 *con t%5 campiono 200 volte al secondo, quindi a 200 Hz  *
 *Applicano il fitro i campionamenti avvengono ogni 10*T  *
 *********************************************************/

if(t%T1 == 0){
  valore = analogRead(A0)*C;
  
  if (contatore < 10){
    campioni[contatore] = valore;
    //somma = somma + campione[contatore];
    contatore++;
  }


  
  if (contatore < NCAMPIONI && flag ==0){
    flag = 1;
    for (i=0; i<NCAMPIONI; i++){
      sommaSlideWindow = campioniSlideWindow[contatore]+sommaSlideWindow;
    }
    sommaSlideWindow = 0;
  }

  if (contatore < NCAMPIONI && flag !=0){
    campioniSlideWindow[contatore] = valore;
   
   for (i=0; i<NCAMPIONI; i++){     sommaSlideWindow = sommaSlideWindow + campioniSlideWindow[i];    }       mediaSlideWindow = sommaSlideWindow/NCAMPIONI;    sommaSlideWindow = 0;   }   if ( contatore >= NCAMPIONI){
      contatore =0;
      for (i=0; i<NCAMPIONI; i++){
         somma = somma + campioni[i];
      }
      mediaMobile = somma/NCAMPIONI;
      somma = 0;
  }
  

  Serial.print(t);
  Serial.print("\t");
  Serial.print(valore,5);
  Serial.print("\t");
  Serial.print(mediaMobile,5);
  Serial.print("\t");
  Serial.print(mediaSlideWindow,5);
  Serial.println();

}
}


In the next picture you can see the graphical results of the filters.
The filter based on the simple moving average seems better (2nd col).

20141106_5ms

and after some minutes:

20141106_5mmms

 

La dura vita di un informatico per hobby ai tempi di Android

Da anni uso sistemi Open Source, nella fattispecie Linux Ubuntu, non perchè io sia un programmatore professionista o un talebano che insegue la sua guerra contro MS Windows, nulla di tutto ciò.

Ho cominciato ad usare Debian GNU Linux e FreeBSD per alcune semplici ragioni che elenco.

1. Sono contro la pirateria informatica

Trovo veramente scorretto ed ingiusto usare software commerciali per fini di lucro senza aver corrisposto i giusti diritti ai realizzatori del software.

Trovo anche sbagliato che molte software house facciano pagare una licenza anche per l’uso a fini di studio di tali SW o per fini diversi dal lucro.

Quindi durante i miei anni universitari decisi di non installare software “craccati” sul mio PC ma di passare direttamente a quello che la comunità Open Source riusciva ad offrire. Parlo degli anni ’90 ed allora l’offerta non era paragonabile ad oggi ma una cosa mi ha colpito, la totale padronanza che mi era permessa nell’usare le risorse hardware del mio PC.

2. Non ho mai posseduto computer potentissimi

Tutti i computer che ho posseduto erano già obsoleti al momento dell’acquisto e grazie all’uso di sistemi e software Open Source li ho usati per svariati anni, un esempio è il PC da cui vi scrivo comprato nel 2009 che ancora oggi uso senza sentire nessuna necessita di cambialo con una macchina più potente.

3. Disponibilità di software per coprire tutte le attività hobbystiche e lavorative

Negli anni la base software disponile è cresciuta in modo pauroso, oggi è davvero completa. Ad esempio c’è sempre stata una carenza di software CAD, oggi non è più vero e esistono soluzioni commerciali liberamente usabili per scopi didattici.

Quindi oggi abbiamo la possibilità di scegliere tra software Open Source e software commerciale e questo credo sia la dimostrazione che Linux è diventato finalmente un ambiente anche desktop e professionale in senso lato come Windows.

4. Voglia di smanettare ed imparare

Avere a disposizione un computer con praticamente tutti i linguaggi di programmazione disponibili è un terribile incentivo, almeno per me, a trovare il modo di risolvere problemi, testare idee, studiare fenomeni o semplicemente provare a fare quello che altri hanno già fatto.

 4. Oggi

Per molti anni per me è stato come vi ho descritto sopra.

Da qualche tempo ho comprato un cellulare android.

Dopo qualche settimana di utilizzo sono rimasto entusiasmato, una potenza di calcolo notevole, trasportabile e collegabile con tutto.

La tentazione è troppo forte, il dispositivo è un computer e quindi perchè non usarlo come tale? Perchè non scrivere delle App?

Detto fatto mi armo di buona volontà, cerco in rete informazioni, scarico Eclipse e l’SDK Android e cominco a smanettare.

Alla fine è più la fatica che il divertimento, il sistema di sviluppo è ben fatto ma la complessità da gestire è TERRIBILE.

Occorre avere una conoscenza multi-linguaggio:

  1. Bisogna saper programmare in JAVA (ok lo avevo messo in conto anche se non mi è mai piaciuto);
  2. Bisogna conoscere le API Android (sono tante, veramente tante anche per un “Ciao mondo”);
  3. Bisogna conoscere XML (l’ambiente di sviluppo agevola con tool grafici, ma la conoscenza è necessaria);
  4. La struttura ad OGGETTI rende l’attività di sviluppo pesante, almeno per chi non è un professionista del settore

Ho trovato una bella guida qui, guida che ho seguito fino a creare la prima interfaccia per l’inserimento dati.

Da questo punto in poi potrei cominciare a realizzare la parte CORE della App, la parte di calcolo, ma la struttura del sistema, il JAVA, la OOP mi stanno veramente rendendo pesante l’attività a tal punto che mi chiedo che forse il tempo in cui bastavano poche istruzioni e librerie da conoscere è passato.

Ormai siamo molto, forse troppo abituati a interfacce avanzatissime, interfacce che rendono l’esperienza utente fantastica, interfacce che spesso sono la ragione per cui un utente acquista un Mac al posto di un PC.

I computer, i cellulari ed il software sono diventati prodotti soggetti ad una moda, e in un certo senso i vari Software Development Kit cercano di assecondare la moda.

Il risultato che oggi abbiamo ambienti di sviluppo sempre più complessi e sempre meno orientati all’utente, ma dedicati a professionisti della programmazione. L’aspetto dell’applicazione, la sua interfaccia, gioca un ruolo fondamentale nel successo di un prodotto. Il contenuto, gli algoritmi implementati, contano molto meno. L’utente è attratto dalla user interface.

Sono sicuro che se oggi all’utente medio vengono fornite due applicazioni per la soluzione di un problema. La prima a riga di comando, completa, funzionale e ben documentata. La seconda con interfaccia grafica attraente, non complea e scarsamente documentata, bene non ho dubbio che commercialmente avrebbe successo la seconda. Il computer è diventato un oggetto  di consumo e con esso l’informatica ed i programmi, questo ha trascinato anche i linguaggi di programmazione in una gara alla complessità che di fatto sta portando la programmazione lontano dagli utenti.

Programmare oggi è molto più complicato rispetto a 10 anni fa, per chi come me non lo fa di professione.

 

 

 

La mia biblioteca oleodinamica

Oggi stavo facedo un pochino di ordine tra le mie cose, in particolare le mie carte, ebbene mi sono accordo che negli anni ho accumulato diversi libri sull’oleodinamica che oggi non si trovano più in commercio.

Ho inserito anche delle tesi che ho reperito su internet.

Per completezza vi riporto l’elenco totale, li ho praticamente letti tutti e sono veramente degli ottimi testi.

Oltre a questi ne ho altri, ma per non offendere gli autori non li cito😉

Il mio consiglio è quello di comprali se li trovate in qualche negozio che vende libri usati.

  1. R. B. Walters, “Sistemi di regolazioni idraulici ed elettroidraulici”, Ed.: Tecniche Nuove, 1994.
  2. Mannesmann Rexroth, autori vari, “Oleodinamica: Fondamenti e componenti”, Ed.: Tecnologia Mannesmann, 1993.
  3. Mannesmann Rexroth, autori vari, “Valvole proporzionali e servovalvole”, Ed.: Tecnologia Mannesmann, 1993.
  4. Mannesmann Rexroth, autori vari, “Progetto e realizzazione degli impianti oleodinamici”, Ed.: Tecnologia Mannesmann, 1993.
  5. Mannesmann Rexroth, autori vari, “Tecnica ed impiego delle valvole a cartucci a 2 vie”, Ed.: Tecnologia Mannesmann, 1993.
  6. Kordak, “Hydrostatic drives with control of the secondary unit”, Ed.: Bosch Rexroth AG
  7. G. Rigamonti, “Oleodinamica e Pneumatica”, Ed.: Hoepli, 1980.
  8. J. Thoma, “Introduzione all’oleodinamica ed ai sistemi oleodinamici”, Ed.: Tecniche Nuove, 1978.
  9. J. Thoma, “Trasmissioni idrostatiche”, Ed.: Tecniche Nuove, 1969.
  10. J. Thoma, “Macchine e componenti idrostatici”, Ed.: Tecniche Nuove, 1979.
  11. Brigitta Lantto, “Tesi: On fluid power control with special reference to multiload conditions in load sensing systems”, Univ. Linkoeping, 1992.
  12. Wolfgang Bauer,”Hydropneumatic suspension systems”, Ed.: Springer,  2011.
  13. Matteo Grott, “Tesi: Sviluppo di sistemi di sospensione ed algoritmi di controllo per mezzi heavy duty”, Università degli stuti di Trento, 2010.
  14. G. Rigamonti, “Sistemi idraulici”, Ed.: Mobil Oil Italian