Tecnicamente's Weblog

Just another WordPress.com weblog

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

Tutorial interessanti, Netgen e Calculix

Netgen e Calculix sono due software meravigliosi e molto utili, ma un tantino ostici da usare.

Ho trovato un sito con due ottimi tutorial, buona lettura.

http://www.libremechanics.com

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

Importare File Dati in Excel (upgrade)

In un post precedente ho già mostrato la soluzione usata in passato per risolvere il fastidioso problema del formato decimale usato per salvare i dati acquisiti da parte di un DAQ.

La soluzione proposta era un breve listato in C da compilare, in questi giorni mi sto appassionando al C++ e nella speranza di non lasciare perdere lo studio causa cronica mancanza di tempo e/o concentrazione ho voluto rielaborare il codice C in C++ usando per quanto mi è possibile una programmazione ad oggetti, che trovo veramente affascinante.

Ecco il codice:

#include <iostream>
#include <fstream>
#include <cstdlib>

using namespace std;

int main(int argc, char *argv[]){
        ifstream in(argv[1]);
        ofstream out(argv[2]);

        char carattere;

        int dot_count = 0;

        if (argc != 3){
                cout << "Uso: " << argv[0] << " <file_in> <file_out>" << endl;
                exit(0);
        }

        while(!in.eof()){
                in.get(carattere);
                if (carattere == EOF) break;
                if (carattere == '.'){
                        dot_count++;
                        if ( dot_count > DOT_LOW_LIMIT){
                                out <<  ',';
                                cout << ',';
                        }
                        else{
                                out  << carattere;
                                cout << carattere;
                        }
                        if (dot_count == DOT_UP_LIMIT) dot_count = 0;
                }
                else{
                        out  << carattere;
                        cout << carattere;
                }
        }

        in.close();
        out.close();

        return 0;
}

Elettronica in supposte

Titolo osè per un articoletto ad aggiornamento continuo su link interessanti sull’elettronica e i componenti:

DIODI:

http://hobbyelettronica.altervista.org/elettr_analog/diodi.pdf

CONTINUA…

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

Come installare Intel(R) Fortran Compiler XE 12.1 su Ubuntu 12.04 LTS

Intel offre da anni una versione gratis del suo compilatore fortran per scopi non commerciali e non c’è dubbio che tale compilatore sia tra i migliori se non il migliore attualmente disponibile.

Quindi se state realizzando un software non commerciale, una bella compilazione con il compilatore Intel e le sue ottimizzazioni per i processori Intel potrebbe darvi grandi soddisfazioni.

Bene cominciamo, per prima cosa occorre il compilatore, lo trovate qui: http://software.intel.com/en-us/articles/non-commercial-software-download/

Scaticate e scompattate il file e lanciate come root il file “install.sh”, vi apparirà il seguente menù:

date invio e andate avanti.

Ovviamente questo tutorial non avrebbe senso se l’installazione fosse stata semplice :), infatti vi trovere subito dei problemi:

Selezionate 2 per analizzare i dettagli.

Ed ecco l’origine dei nostri mali:

Provate a forzare l’installazione selezionando 1.

Legge la licenza ed alla fine digitate “accept”.

Alla schermata per l’attivazione scegliete il menù 1:

A questo punto occore inserire il codice seriale che vi è stato spedito via email durante la registrazione per il download del compilatore.

Alla seguente schermata indicate dove installare i files, /opt va benissino:

Bene siamo quasi alla fine seguite le indicazione dell’ultima schermata:

date quindi un bel “$ sudo /opt/intel/bin/compilervars.sh ia32”

Nel mio caso tale comando non ha dato esito, ho quindi provveduto per via manuale alla modifica della variabile $PATH aggiungendo il percorso dei file binari del compilatore.

date i seguenti comandi:

$ cd
$ gedit .profile

e modificate il file come segue:

tutto fatto 🙂

Buon lavoro

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