Tecnicamente's Weblog

Just another WordPress.com weblog

Archivi Categorie: Arduino

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.

Annunci

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

 

Prepariamoci a realizzare un rilevatore di campi elettrici con Arduino

Il motivo dei due articoli precedenti, “Utilizzo di un diplay 7 segmenti con Arduino” e ” Grafici in tempo reale con Arduino o altro dispositivo su porta seriale“, è molto semplice… volevo realizzare un rilevatore di campi elettro-magnetici.

In giro trovate diverse guide, come ad esempio questa o meglio ancora  quest’altro video.

Quindi ravanando nella “scatola delle cose elettroniche” ho trovato tutto in necessario per avviare il progetto.

La cosa bella degli hobby è che ti mettono di fronte a cose non conosciute e chi è affetto da nerdite non può fare a meno che perdere di vista il progetto e cominciare a sforzarsi di capire perchè c’è questo o quello, e perchè si fa così, ecc..

Alla fine ho fatto interessanti scoperte:

  1. Tutti i progetti che usano Arduino, una antenna e una resistenza non rilevano nessun campo elettromagnetico
  2. Le antenne sono un modo meraviglioso da esplorare… mettere una cavetto a caso può solo peggiorare i risultati del progetto
  3. Arduino è sensibile in modo naturale ai campi elettrici (OK facciamo un rilevatore di campi elettrici 🙂 )
  4. La teoria dei segnali è veramente affascinante.

Che dire lo scopo di un progetto è imparare ed ho imparato e continuo ad imparare veramente tanto, mi pare giusto condividere parte delle cose che ho trovato in rete nella speranza che siano utili anche al altri che stanno facendo la mia stessa esperienza.

Per le antenne vi suggerisco questa semplice guida introduttiva, cliccate qui.

Per quanto riguarda l’acquisizione dati vi consiglio questi due link:

https://sites.google.com/site/measuringstuff/the-arduino

conversione AD

In merito alla sensibilità natura di Arduino ai campi elettrici fate la prova usando un semplice analogRead(A0) o qualsiasi altra porta senza collegare nulla al PIN, avvicinate Arduino ad una presa o lampade e niente di strano che vi troviate delle misure di questo tipo:

Campionamento del campo elettrico con arduino

Campionamento del campo elettrico con arduino

Introdurre una antenna nel sistema per quanto essa sia mal fatta aiuta ad aumentare il valore della grandezza campionata, qui di seguito le immagini e lo schema di come ho fatto io:

emf_bbSchema corrispondente:

Schema rilevatore campi elettrici

Schema rilevatore campi elettrici

Qui vi mostro l’ultima misura fatta che riporta i valori in Volt, una frequenza di campionamento pari a 200Hz, il codice usato lo trovate qui. Le variazioni sono date dalla variazione delle utenze collegate alla presa elettrica, presa che dista circa 10-15 cm dall’antenna.

Valori di tensione indotte sull'antenna dal campo elettrico

Valori di tensione indotte sull’antenna dal campo elettrico

Ok, questo è tutto, per un po’ di tempo credo non avrò la possibilità di andare avanti con l’attività.

Grafici in tempo reale con Arduino o altro dispositivo su porta seriale

Un secondo pezzo utile per il progetto a cui sto lavorando da qualche giorno è la rappresentazione grafica dei dati campionati con Arduino.

Tale attività è facilmente realizzabile sia su Windows che su Linux o OSX, vediamo cosa ci occorre.

Procuratevi il software KST, e scaricate la versione adeguata al mostro sistema operativo da qui.

Per poter usare KST è necessario che i dati provenienti dalla comunicazione seriale siano salvati su un file, per fare ciò uso i seguenti software:

Entrambi i software permettono di stabilire una comunicazione su porta seriale e di salvare tutti i contenuti su un file.

Tralascio come fare in quanto i due software sono molto intuitivi e passo direttamente a KST.

Quindi dopo aver lanciato Realterm/GTKterm o altro programma che salva la comunicazione su un file testo avviate KST.

Cliccate sulla bacchetta magica:

Immagine1

Nella finestra “Data Wizard” indicate il nome del file e la voce “Time Interval“:

Immagine2

Selezionate i dati che volete riportare sul grafico, nel mio caso sto usando un formato dovhe ho un “INDEX” automatico e sulla stessa riga il campionamento di due segnali, quindi ho un file testo con due colonne di numeri campionati.

Immagine3Cliccate Next e nella schemata successiva mettete le seguenti impostazioni:

Immagine4

Ed ecco il risultato, un bel grafico che si aggiorna in tempo reale:

Immagine5

Buon lavoro 😉

 

Utilizzo di un display 7 segmenti con Arduino

In questi giorni di vacanza provo a rilassarmi ravanando nella scatole di pezzi sparsi, nella scatola dove tengo ormai fermo da quasi un anno il mio vecchio Arduino.

Ravanando cosa mi trovo?

Delle resistenze, un po’ di fili, un display a 7 segmenti… Ok facciamo un misuratore di campi elettromagnetici, ma avanziamo per passi, prima proviamo ad usare il display.

Quindi il display è un TDSR3150, la disposizione dei pin è la seguente (tratto dal datasheet della VISHAY):

pin_7s

L’idea iniziale è di misurare il campo elettromagnetico e poi proporre in uscita un range di valore da 0 a 10, dove il dieci è rappresentato dall’accensione dei segmenti: “b”, “c” e “DP”.

Per ora tralascio il progetto del misurare il campo elettromagnetico dato che merita un pesante approfondimento su come progettare l’antenna 🙂 e passo direttamente all’uso del display in questione che può tornare utilie per altre applicazioni.

Per governare il display occore che uno dei PIN 3 o 8 sia collegato al “catodo”, quindi all’alimentazione +5v del nostro arduino, i restanti pin sono stati collegati alle uscite della scheda. Tali uscite sono state configurate tutte come  “digitali”.

Qui le funzioni definite per stampare i numeri:

/* ld7.h v1.0
 La funzione
 void writeDiplay(int) permette di rapresentare i seguenti numeri e simboli sul display:
 0 --> 0
 1 --> 1
 2 --> 2
 3 --> 3
 4 --> 4
 5 --> 5
 6 --> 6
 7 --> 7
 8 --> 8
 9 --> 9
 10 --> 1.

 Se in ingresso è fornito un valore <0 il dato visualizzato è 0, se è fornito
 un valore >10 il dato vizualizzato è 1.
*/

/* definizione dei pin di collegamento */
/* Il progetto usa un display a 7 segmenti con il seguente pinout:

     +------------+
 1---|            |---10
     |     a      |
 2---|   +---+    |---9
     |  f| g |b   |
 3---|   +---+    |---8
     |  e| d |c DP|
 4---|   +---+  * |---7
     |            |
 5---|            |---6
     +------------+

 1 g
 2 f
 3 A(C)
 4 e
 5 d
 6 DP
 7 c
 8 A(C)
 9 b
 10 a
 con la funzione void setPinDisplay(int pinDisplay, int pinArduino)
 è possibile abbinare i pin tra arduino e diplay
*/

/* definisco ON e OFF per rendere più facile la lettura dello stato led */
/* in quanto di mio diplay ha un collegamento al CATODO                 */
#define ON LOW
#define OFF HIGH

static unsigned short int LedPin1;
static unsigned short int LedPin2;
static unsigned short int LedPin3;
static unsigned short int LedPin4;
static unsigned short int LedPin5;
static unsigned short int LedPin6;
static unsigned short int LedPin7;
static unsigned short int LedPin8;
static unsigned short int LedPin9;
static unsigned short int LedPin10;

void LD_setPinDisplay(int pinDisplay, int pinArduino){
 if (pinDisplay == 1) LedPin1 = pinArduino;
 if (pinDisplay == 2) LedPin2 = pinArduino;
 if (pinDisplay == 3) LedPin3 = pinArduino;
 if (pinDisplay == 4) LedPin4 = pinArduino;
 if (pinDisplay == 5) LedPin5 = pinArduino;
 if (pinDisplay == 6) LedPin6 = pinArduino;
 if (pinDisplay == 7) LedPin7 = pinArduino;
 if (pinDisplay == 8) LedPin8 = pinArduino;
 if (pinDisplay == 9) LedPin9 = pinArduino;
 if (pinDisplay == 10) LedPin10 = pinArduino;
}

/* definizione delle funzioni di visualizzazione*/
void LD_writeDisplay(int numero){
 /* questa è solo una funzione di test */
 if (numero == 0){
 digitalWrite(LedPin1,OFF);
 digitalWrite(LedPin2,ON);
 digitalWrite(LedPin4,ON);
 digitalWrite(LedPin5,ON);
 digitalWrite(LedPin6,OFF);
 digitalWrite(LedPin7,ON);
 digitalWrite(LedPin9,ON);
 digitalWrite(LedPin10,ON);
 }
 if (numero == 1){
 digitalWrite(LedPin1,OFF);
 digitalWrite(LedPin2,OFF);
 digitalWrite(LedPin4,OFF);
 digitalWrite(LedPin5,OFF);
 digitalWrite(LedPin6,OFF);
 digitalWrite(LedPin7,ON);
 digitalWrite(LedPin9,ON);
 digitalWrite(LedPin10,OFF);
 }
 if (numero == 2){
 digitalWrite(LedPin1,ON);
 digitalWrite(LedPin2,OFF);
 digitalWrite(LedPin4,ON);
 digitalWrite(LedPin5,ON);
 digitalWrite(LedPin6,OFF);
 digitalWrite(LedPin7,OFF);
 digitalWrite(LedPin9,ON);
 digitalWrite(LedPin10,ON);
 }
 if (numero == 3){
 digitalWrite(LedPin1,ON);
 digitalWrite(LedPin2,OFF);
 digitalWrite(LedPin4,OFF);
 digitalWrite(LedPin5,ON);
 digitalWrite(LedPin6,OFF);
 digitalWrite(LedPin7,ON);
 digitalWrite(LedPin9,ON);
 digitalWrite(LedPin10,ON);
 }
 if (numero == 4){
 digitalWrite(LedPin1,ON);
 digitalWrite(LedPin2,ON);
 digitalWrite(LedPin4,OFF);
 digitalWrite(LedPin5,OFF);
 digitalWrite(LedPin6,OFF);
 digitalWrite(LedPin7,ON);
 digitalWrite(LedPin9,ON);
 digitalWrite(LedPin10,OFF);
 }
 if(numero == 5){
 digitalWrite(LedPin1,ON);
 digitalWrite(LedPin2,ON);
 digitalWrite(LedPin4,OFF);
 digitalWrite(LedPin5,ON);
 digitalWrite(LedPin6,OFF);
 digitalWrite(LedPin7,ON);
 digitalWrite(LedPin9,OFF);
 digitalWrite(LedPin10,ON);
 }
 if(numero == 6){
 digitalWrite(LedPin1,ON);
 digitalWrite(LedPin2,ON);
 digitalWrite(LedPin4,ON);
 digitalWrite(LedPin5,ON);
 digitalWrite(LedPin6,OFF);
 digitalWrite(LedPin7,ON);
 digitalWrite(LedPin9,OFF);
 digitalWrite(LedPin10,ON);
 }
 if(numero == 7){
 digitalWrite(LedPin1,OFF);
 digitalWrite(LedPin2,OFF);
 digitalWrite(LedPin4,OFF);
 digitalWrite(LedPin5,OFF);
 digitalWrite(LedPin6,OFF);
 digitalWrite(LedPin7,ON);
 digitalWrite(LedPin9,ON);
 digitalWrite(LedPin10,ON);
 }
 if(numero == 8){
 digitalWrite(LedPin1,ON);
 digitalWrite(LedPin2,ON);
 digitalWrite(LedPin4,ON);
 digitalWrite(LedPin5,ON);
 digitalWrite(LedPin6,OFF);
 digitalWrite(LedPin7,ON);
 digitalWrite(LedPin9,ON);
 digitalWrite(LedPin10,ON);
 }
 if(numero ==9){
 digitalWrite(LedPin1,ON);
 digitalWrite(LedPin2,ON);
 digitalWrite(LedPin4,OFF);
 digitalWrite(LedPin5,OFF);
 digitalWrite(LedPin6,OFF);
 digitalWrite(LedPin7,ON);
 digitalWrite(LedPin9,ON);
 digitalWrite(LedPin10,ON);
 }
 if (numero == 10){
 digitalWrite(LedPin1,OFF);
 digitalWrite(LedPin2,OFF);
 digitalWrite(LedPin4,OFF);
 digitalWrite(LedPin5,OFF);
 digitalWrite(LedPin6,ON);
 digitalWrite(LedPin7,ON);
 digitalWrite(LedPin9,ON);
 digitalWrite(LedPin10,OFF);
 }
}

void LD_resetDisplay(void){
 digitalWrite(LedPin1,OFF);
 digitalWrite(LedPin2,OFF);
 digitalWrite(LedPin4,OFF);
 digitalWrite(LedPin5,OFF);
 digitalWrite(LedPin6,OFF);
 digitalWrite(LedPin7,OFF);
 digitalWrite(LedPin9,OFF);
 digitalWrite(LedPin10,OFF);
}

void LD_setArduinoOutDisplay(void){
 pinMode(LedPin1,OUTPUT);
 pinMode(LedPin2,OUTPUT);
 pinMode(LedPin4,OUTPUT);
 pinMode(LedPin5,OUTPUT);
 pinMode(LedPin6,OUTPUT);
 pinMode(LedPin7,OUTPUT);
 pinMode(LedPin9,OUTPUT);
 pinMode(LedPin10,OUTPUT);
}

 

Qui il codice principale

/* 18/04/2014
 prima stesura della funzione che permette di visualizzare a display la scala da 0-9 e il lampeggio DP
 in fase di accensione
18/04/2014
 aggiunta la lettura dei valori dall'antenna
25/04/2014
 Codice organizzato in modo modulare e testato con code::blocks 12.11 per arduino
 */
#include <Arduino.h> /* Necessario se usate code::blocks come ambiente di sviluppo, diversamente rimuvere */
#include "ld7.h"
/* definizione PIN antenna
\/
 |
 |
 +--a0
 |
 R3M3K
 |
 GND
 */
#define analogIn A0
#define FQ 1/(50.) /* frequenza di campionamento pari al doppio della frequenza che mi interessa (50 Hz) */
void setup(){
 /*attivo la comunicazione seriale */
 Serial.begin(57600);
/* definizione PIN display 7 segmenti */
 LD_setPinDisplay(1,2);
 LD_setPinDisplay(2,3);
 LD_setPinDisplay(4,4);
 LD_setPinDisplay(5,5);
 LD_setPinDisplay(6,6);
 LD_setPinDisplay(7,7);
 LD_setPinDisplay(9,8);
 LD_setPinDisplay(10,9);
/*configurazione dei PIN */
 LD_setArduinoOutDisplay();
/* setto tutti i pin LOW affinche siano spenti */
 LD_resetDisplay();
}
int flag = 0;
void test(void){
 /* ciclo di test solo per verificare che i numeri siano
 rappresentati correttamente
 */
 for(int i=0;i<11;i++){
 LD_writeDisplay(i);
 delay(2000);
 }
}
int segnaleAntenna(void){
 /* definisco la sensibilità minima della conversione A/D */
 //const double c = 0.0048875855;
 return analogRead(analogIn);
}
void loop(void){
 unsigned long t;
 int valore;
if (flag ==0){
 test();
 LD_resetDisplay();
 flag=1;
 }
 //resetDisplay();
 t = millis();
 if(t%100 ==0){
 delay(1);
 valore = segnaleAntenna();
 Serial.print(valore);
 Serial.print(" ");
 Serial.println(analogRead(A1));
 }
 if(t%1000 == 0){
 valore = map(valore,0,100,0,10);
 LD_writeDisplay(valore);
 delay(1);
 }
}

Arduino, F-BUS del Nokia3310 ed invio di SMS

Premessa

E’ passato molto tempo da quando ho deciso di sperimentare la comunicazione tramite Arduino ed un Nokia 3310 e dopo qualche prova e molte ricerche su internet ci sono riuscito.

E’ doveroso dire che non sarei mai riuscito nell’impresa senza le importanti informazioni trovati nei seguenti siti:

http://www.embedtronics.com/nokia/fbus.html

http://www.insidegadgets.com/2013/01/12/how-to-use-nokia-f-bus-to-send-an-sms-message/

Consiglio vivamente le lettura e lo studio delle pagine in essi contenuti, se poi avete qualche problema o volete passare ad usare qualche cosa di rapido e immediato uso, allora spero che queste note possano esservi di aiuto.

Come collegare Arduino al Nokia 3310

In post precedenti ho descritto come Arduino alla porta seriale di un qualsiasi dispositivo, nel mio caso un cellulare Siemens M35, qui i post in questione:

Arduino, Max232 e comunicazione seriale – Parte 1

Arduino, Max232 e comunicazione seriale – Parte 2

Per un po’ di tempo mi sono accanito a far funzionare la comunicazione tra il mio Arduino ed il mio Nokia 3310 usando il MAX232, alla fine ho fatto una terribile scoperta… i livelli di tensione non erano compatibili!

Va bene, allora come possiamo interfacciare il Nokia all’Arduino?

In un modo molto semplice, rimuovendo la batteria  si accede ai contatti che ci interessano.

Pin-Out Nokia 3310

Pin-Out Nokia 3310

Ho saldato i pin 2, 3 e 4 a dei cavi e realizzato il seguente schema, dove tutto è direttamente collegato all’Arduino.

collegamento

Ok fatto ciò possiamo passare al software.

Comunicazione 7 e 8 bit

Un aspetto poco piacevole della comunicazione è che il nostro Arduino comunica i dati utilizzando una codifica ad 8 bit, il Nokia 3310 legge i dati usando una codifica a 7 bit.

Cosa vuol dire ciò?

La risposta è semplice, se inviamo da Arduino a Nokia la stringa “OK”, si ha che Arduino invierà due stringe da 8 bit:

O -> 01001111   [posizioni -> 7 6 5 4 3 2 1 0]

K -> 01001000 [posizioni -> 7 6 5 4 3 2 1 0]

Il nokia leggerà i messaggi a blocchi di 7 bit, quindi il primo carattere ricevuto sarà

1001111 – > O  [posizioni -> 6 5 4 3 2 1 0]

Il secondo carattere avrà come bit in posizione 0 il bit che nel primo carattere era in posizione 7, quindi la lettura effettuata dal Nokia è

0011110 – > nessun carattere ASCII associato

Ciò vuol dire che le stringhe di messaggi che voglio inviare tramite SMS devono essere codificate da 8 a 7 bit, a tal proposito ho scritto in piccolo programma in C che mi permette di ottenere le stringhe già codificate e di eseguire qualche debug.

#include <stdio.h> 
#include <string.h> 

int main(void){ 

    //String test; 128 
    char input[4]; 
    char msg[4]; 
    char decode[4]; 
    int len; 

    unsigned char c, w; 
    int i,n, shift, x; 
    len = strlen(input); 
    shift = 0; decode[0] = 0; 

    input[0] = 'h'; 
    input[1] = 'e'; 
    input[2] = 'l'; 
    input[3] = 'o'; 

    /* Decode into 7 bit characters */ 
    for (n=0; n<len; ++n) 
            { 
            c = input[n] & 0x7f; 
            c >>= shift; 
            w = input[n+1] & 0x7f; 
            w <<= (7-shift); 
            shift +=1; 
            c = c | w; 
            if (shift == 7) 
                    { 
                    shift = 0x00; 
                    n++; 
                    } 
            x = strlen(decode); 
            decode[x] = c; 
            decode[x+1] = 0; 
            } 

    // Display decoded output as Hex 
    for (i = 0; i < strlen(decode); i++) 
      { 
         printf("%c",decode[i]); 
      //sprintf(msg,"%.02X ",(unsigned char)decode[i]); 
      } 
    for(i=0;i<4;i++) {printf("%x",decode[i]);} 

}

Allo stesso modo il seguente codice mi permette di eseguire la decodifica da 7 bit a 8 bit per leggere le stringhe provenienti dal Nokia e di cui riporto solo la parte più significativa.

//decodifica
     j=48;
     shift = 0;
        for(i=48;i<(152+MsgLen);i++){
             //c = buff_decode[i] & 0x7f;
             if(i==48){
                 c = buff_decode[i] & 0x7f;
                 decode[i-48] = c;
             }
             else{
                 w = buff_decode[i-48+1];
                 w >>= 7-shift;
                 c = buff_decode[i-48];
                 shift = shift+1;
                 c <<= shift;
                 c = w | c;
                 c = c & 0x7f;
                 decode[i-48] = c;
                 //c = w;
             }
         }

Andiamo al sodo, il CODICE

Qui il codice che ho usato per inviare il mio primo SMS tramite Arduino ed il Nokia 3310, buon divertimento, e mi raccomando se migliorate qualche cosa fatemi sapere 😉


unsigned char FBusFrame[200];

// Numero del centro messaggi del gestore
// WIND     +393205858500 
// Vodafone +393492000200
// TIM      +393359609600
// TRE      +393916263333
// Dopo 0x91 si deve inserire il numero del centro messaggi in formato esadecimale a coppie di cifre invertire
// ES: WIND +39 -> 0x93 ; 32 -> 0x23 ; 05 -> 0x50 ; 58 -> 0x85 ; 58 -> 0x85 ; 0 -> 0x00 ; 0 -> 0x00
// Il nokia si attende un numero composto da 20 numeri, quindi quindi essendo in Italia il formato composto da 12 numeri
// occorre inserire 8 zeri finali, che si traduce in 4 0x00
unsigned char SMSC[] = {0x07, 0x91, 0x93, 0x23, 0x50, 0x58, 0x58, 0x00, 0x00, 0x00, 0x00, 0x00};

// Numero che riceve l'SMS. dopo 0x81 inserire il numero del destinatario come già fatto per il centro messaggi
// non occore inserire gli 0x00 di chiudura, il formato è libero
// Es: 0123456789 
unsigned char RecipientNo[] = {0x0A, 0x81, 0x10, 0x32, 0x54, 0x76, 0x98};

void setup() { 
  // inizializzo la comunicazione su seriale a 115200 kbs come richiesto dal protocollo F-bus
  Serial.begin(115200);
  delay(100);
} 

void loop() { 
  // Inizializzazione dell'F-Bus inviando 128 volte il carattere 'U', corrispondente ad un segnale '0101010101...'
  for (int x = 0; x < 128; x++) {
    Serial.write("U");
  } 

  // Invio l'SMS
  SendSMS("EVVAI, il primo SMS");

  // Leggo la risposta dal Nokia, questa parte va estesa con l'individuazione e la decodifica di eventuali SMS di riposta ricevuti dal Nokia
  while (1) {
    while (Serial.available() > 0) { 
      int incomingByte = Serial.read(); 
      Serial.print(incomingByte, HEX); 
      Serial.print(" "); 
    }
  }
} 

unsigned char SendSMS(const char *Message) {
  // 
  unsigned char j = 0;
  memset(FBusFrame, 0, sizeof(FBusFrame));

  unsigned char MsgLen = strlen(Message), FrameSize = 0;
  unsigned char c, w, n, shift = 0, frameIndex = 0;
  unsigned char oddCheckSum, evenCheckSum = 0, SeqNo = 0x43;
  unsigned char MsgStartIndex = 48; // Indice di inizio dell'SMS

  // Codifica in 7 bit
  for (n = 0; n < MsgLen; n++) {
    c = Message[n] & 0x7f;
    c >>= shift;
    w = Message[n+1] & 0x7f;
    w <<= (7-shift);
    shift += 1;
    c = c | w;
    if (shift == 7) {
      shift = 0x00;
      n++;
    }
    FBusFrame[frameIndex + MsgStartIndex] = c;
    frameIndex++;
  }

  FBusFrame[frameIndex + MsgStartIndex] = 0x01;
  FrameSize = frameIndex + 44; // The size of the frame is frameIndex+48 (FrameIndex + 48 + 1 - 5)

  // Preparazione del frame prima del contenuto dell'SMS secondo il protocollo F-bus 
  FBusFrame[0] = 0x1E;
  FBusFrame[1] = 0x00;
  FBusFrame[2] = 0x0C;
  FBusFrame[3] = 0x02;
  FBusFrame[4] = 0x00;
  FBusFrame[5] = FrameSize;
  FBusFrame[6] = 0x00;
  FBusFrame[7] = 0x01;
  FBusFrame[8] = 0x00;
  FBusFrame[9] = 0x01;
  FBusFrame[10] = 0x02;
  FBusFrame[11] = 0x00;

  // Inserimento del numero del centro messaggi
  for (j = 0; j < sizeof(SMSC); j++) {
    FBusFrame[12 + j] = SMSC[j];
  }

  FBusFrame[24] = 0x15; //Message type
  FBusFrame[28] = MsgLen; //Lunghezza del messaggio (non compresso)

  // Inserimento del numero del ricevente
  for (j = 0; j < sizeof(RecipientNo); j++) {
    FBusFrame[j + 29] = RecipientNo[j];
  }

  FBusFrame[41] = 0xA7; // Validity period

  // Check if the Framesize is odd or even
  if (FrameSize & 0x01) {
    frameIndex = FrameSize + 5;
    FBusFrame[frameIndex] = SeqNo;
    frameIndex++;
    FBusFrame[frameIndex] = 0; // Insert to make the Frame even
    frameIndex++;
  }
  else {
    frameIndex = FrameSize + 5;
    FBusFrame[frameIndex] = SeqNo;
    frameIndex++;
  }

  // Calculate the checksum from the start of the frame to the end of the frame
  for (unsigned char i = 0; i < frameIndex+2; i += 2) {
    oddCheckSum ^= FBusFrame[i];
    evenCheckSum ^= FBusFrame[i+1];
  }
  FBusFrame[frameIndex] = oddCheckSum;
  FBusFrame[frameIndex+1] = evenCheckSum;

  // Invio dell'intero frame al Nokia 3310
  for (unsigned char j = 0; j < (frameIndex+2); j++) {
    // Debug to check in hex what we are sending
    //Serial.print(FBusFrame [j], HEX);
    //Serial.print(" ");

    Serial.write(FBusFrame [j]);
  }
}

Misto fritto di Link FBUS, Nokia 3310 e Arduino

Causa prematura morte del Siemes M35i su cui stavo basando tutto il mio progetto del sistema di avvisi tramite SMS mi trovo costretto a ravanare in vecchi cassetti per un nuovo cellulare.

La notizia buona è che ho trovato un fiammante Nokia 3310, la cattiva e’ che non posso usare la comunicazione su porta seriale tramite comandi AT ma mi mi devo affidare al sistema FBUS di Nokia.

Per ora mi limito a inserire una lista di link per dipanare l’argomento, spero più avanti di riuscire a produrre qualcosa.

Buona lettura.

PIN OUT Nokia 3310: http://pinouts.ru/CellularPhones-Nokia/nokia_3310_pinout.shtml

Protocollo F-BUS: http://www.embedtronics.com/nokia/fbus.html

Schema cavo collegamento a FBUS: http://www.nokia-tuning.net/index.php?s=cablefbus

Progetti vari:

http://www.avrfreaks.net/index.php?name=PNphpBB2&file=viewtopic&t=59687

http://www.avrfreaks.net/index.php?name=PNphpBB2&file=printview&t=59687&start=20

http://www.ucdevelopers.page.tl/Tutorial-Nokia-3310-with-AT89S52.htm

http://pastebin.com/a52XLuhD

Alcuni schemi ed indicazioni utili per nokia 3310 ed il mio caro siemens M35 (proverò il circuito che emula la batteria 🙂 )

http://www.saunalahti.fi/~tovaska/gsm/index.html

Arduino, MAX232 e comunicazione seriale – Parte 2

Nel post precedente abbiamo visto il circuito che occorre realizzare per creare l’interfaccia hardware che permetta ad Arduino di avere una comunicazione seriale secondo il protocollo RS232.

La prima cosa da fare è includere la libreria nel nostro programma, indicare i PIN che vogliamo usare come RX ( comunicazione TTL in ingresso) e TX (comunicazione TTL in uscita).

#include <SoftwareSerial.h>
#define RX 6
#define TX 7
SoftwareSerial mySerial(RX, TX);

Con l’istruzione SoftwareSerial si definisce una interfaccia seriale dal nome mySerial indicando i PIN adibiti a RX ed a TX.

Nel caso si voglia usare anche il secondo canale di trasmissione disponibile nel MAX232 su può definire una seconda interfaccia usando un altro nome ed altri PIN:

SoftwareSerial secondSerial(3,4)

Abbiamo definito i PIN che trasmettono i dati, ma non abbiamo ancora definito di che tipo sono i dati da trasmettere, per tale motivo occorre dichiarare le variabili tx ed rx, che sono rispettivamente l’informazione spedita da Arduino e l’informazione ricevuto.

Tali variabili sono definite come byte, tale tipo memorizza 8 bit, permettendo di avere dei valori da 0 a 255.

byte tx = 0;    // variabile per contenere il carattere inviato
byte rx = 0;    // variabile per contenere il carattere ricevuto

Giunti a questo punto abbiamo definito sia l’interfaccia hardware che software di comunicazione, mancano ancora ancora settaggi fondamentali per la connessione come ad esempio la velocità di trasmissione dei dati.

Per eseguire dei test e dei debug uso due connessioni seriali, una dal PC ad Arduino ed una seconda da Arduino al PC (mySerial).

void setup()
    {
    Serial.begin(19200); // imposto la UART per lavorare a 19200
    pinMode(led, OUTPUT); // imposto il pin sul quale è collegato il led come uscita
    Serial.flush(); // svuoto il buffer di ricezione seriale

        mySerial.begin(19200);
        mySerial.flush();
        Serial.println("Avvio della comunicazione");
    }

Riorganizzando quanto detto in un unico programma abbiamo quanto segue:

/*

*/

#include <SoftwareSerial.h>
#define RX 6
#define TX 7
SoftwareSerial mySerial(RX, TX);

#define led 13  // led connesso al pin n°13

byte tx = 0;
byte rx = 0;    // variabile per contenere il carattere ricevuto

void setup()
    {
    Serial.begin(19200); // imposto la UART per lavorare a 19200
    pinMode(led, OUTPUT); // imposto il pin sul quale è collegato il led come uscita
    Serial.flush(); // svuoto il buffer di ricezione seriale

        mySerial.begin(19200);
        mySerial.flush();
        Serial.println("Avvio della comunicazione");
    }

void loop()
    {
        int flag=0;

    while (Serial.available() >0) // Controllo se il buffer di ricezione contiene qualcosa
        {
        tx = Serial.read(); // leggo il carattere ricevuto e lo memorizzo in rx
        mySerial.write(tx);
        Serial.print("Arduino TX ->  ");
        Serial.write(tx);
        Serial.println();

        flag = 1; // per scrivere il carattere "CR" su mySerial
        }

        if (flag == 1){
                    mySerial.println();
                    flag = 0;
                }

                if (digitalRead(RX)== 1)
                {
                    Serial.println("-------");
                }
                else
                {
                  Serial.print("RX <- ");
                  Serial.println(RX);
                }

        while (mySerial.available()>0)
                {
                  rx = mySerial.read();
                  Serial.write(rx);
                  flag = 1;
                }
                if (flag == 1){
                    Serial.println();
                    flag = 0;
                }
delay(1000);
}

Nel prossimo post vedremo come fare il debug e se finalemnte il cellulare risponde ai comandi

Arduino, Max232 e comunicazione seriale – Parte 1

Dopo vari test e semplici esercizi di studio con Arduino è giunto il momento di mettere in piedi un progetto ambizioso, permettere ad Arduino di comunicare con un cellulare o un modulo GSM, in modo da inviare informazioni e ricevere comandi tramite SMS.

Ma i grandi progetti cominciano con piccoli passi, e nel mio caso il primo passo da fare e permettere la comunicazione tra Arduino e un telefono cellulare, usando i classici comandi “AT“.

Se come me state pensando di usare il PIN 0 ed il PIN 1 per collegare Arduino al cellulare, vi annuncio di lasciar perdere, lo sbaglio è già stato fatto da me.

I PIN in questione sono già utilizzati dalla comunicazione seriale che instauriamo con Arduino quando lo colleghiamo al PC tramite cavo USB.

Occorre quindi far ricorso ad altre risorse, in particolare possiamo usare due uscite digitali tra quelle disponibili (nel mio caso PIN 6 e PIN 7), e far ricorso alle librerie: “SoftwareSerial.h” che sono comprese nell’ambiente di sviluppo.

Le librerie SoftwareSerial ci permetterano di impostare i precedenti PIN 6 e 7 come i PIN adeguati ad una comunicazione tramite TTL.
In tal modo potremo usare tutti i comandi classici della comunicazione seriale di Arduino su questi due nuovi PIN.
La condizione da rispettare è che la forma “Serial.xxxxx()” diventi una forma del tipo “mySerial.xxxxx()“, per tutta la documentazione del caso vi invito alla lettura del link: http://arduino.cc/en/Reference/SoftwareSerial.

Oltre alla libreria software ci occorre un famosissimo integrato, il MAX232!
Il Maxim MAX232 permette di convertire i segnali TTL provelienti dai PIN 6 e 7 nei segnali previsti dalla comunicazione RS232, per tutte le informazioni del caso cliccate qui.

Come potete vedere nel sito ufficiale della Maxim, lo schema del MAX232 è:

L’integrato permettere di realizzare due comunicazioni seriali secondo l’RS232 semplicemente usando altri due PIN di Arduino, ma per il mio scopo va bene utilizzare solo un canale di trasmissione per tale motivo nello schema successivo trovate collegati solo i PIN 11 e 12 (T1in e R1out) ad Arduino.

La porta seriale del cellulare sarà invece collegata ai PIN 13 e14 (R1in e T1out):

Dallo schema del MAX232 si vede benissimo che esso esegue un inversione del segnale di ingresso, i segnali TTL inviati da Arduino.

I segnali TTL inviati da Arduino posso assumere i valori:

  • 0V per esprimere lo “0” logico;
  • +5V per esprimere l’ “1” logico.

Tali livelli logici sono inviati al MAX232 che li inverte dando in uscita:

TTL RS-232
livello logico “0”/ 0V +10 V

Lo Standard RS232 prevede un valore da +6V a -15V

livello logico “1” / +5V -10 V

Lo Standard RS232 prevede un valore da -6V a -15V

Quindi se avete qualche dubbio sul corretto funzionamento dell’integrato basta collegare il PIN T1in di ingresso a +5V ed in uscita al T1out dovete leggere un valore da -6V a -15V.

Ripetendo il test mettendo a massa il PIN T1in il valore in uscita al T1out deve essere compreso tra +6V e +15V.

Il collegamento tra Arduino, il MAX232 ed il connettore DB9 dove collegare il cellulare è stato fatto rispettando lo schema ed i commenti che trovate qui.

Nel mio caso ho:
Vcc = 5 volt, prelevati dall’opportuno PIN di Arduino, verificate che il vostro max232 richieda 5 Volt e non di più.
RX = PIN 6
TX = PIN 7
GND = PIN GND di Arduino
Per il condensatore sul PIN 16 del max232 ho usato un condensatore da 100uF, causa non disponibilità del 10uF, e tutto funziona benissimo.

Bene con SoftwareSerial.h, il maxim max232, ed una manciata di condensatori abbiamo creato l’interfaccia che ci serve per la comunicazione, ma la via è ancora lunga ed il debug anche, quindi nella seconda parte metteremo mano ad un po’ di codice e a qualche altro accessorio che potrebbe servire.

Il circuito realizzato, scusate la qualità, è quindi il seguente:

Arduino, si comincia

Questa sera mi sono finalmente convinto a comprare uno starter Kit per Arduino UNO.

Prossimamente su questi schermi 🙂