Archivio mensile:febbraio 2013

Installazione interruttore su multimetro a pinza

Questo è un mio piccolo tutorial su come installare uno switch smd al mio nuovo multimetro.

Qualche settimana fa ho acquistato questo piccolo multimetro indicato per componenti smd.

Molto utile e poco ingombrante, funziona con due batterie bottone.

L’unica pecca è che una volta acceso si spegne da solo dopo 10 minuti.
Un pò troppo per la durata delle batterie, così ho deciso di installare un piccolo switch.

Il miglior posto per installarlo era sul lato, così ho praticato un piccolo foro con il mio dremel.
Fatto questo ho tagliato con una lama per bisturi, una delle due trace che portavano l’alimentazione dalle batterie verso la circuiteria.

Ho grattato via lo smalto tirando fuori il rame e ho saldato il tutto allo switch.

Et voilà!

2013-02-21 15.13.47 2013-02-21 15.13.56 2013-02-21 15.14.02 2013-02-21 15.14.09 2013-02-21 15.29.53 2013-02-21 15.33.01 2013-02-21 15.42.16 2013-02-21 15.42.23 2013-02-21 16.45.49 2013-02-21 16.49.28 2013-02-21 16.50.32 2013-02-21 16.50.41 2013-02-21 16.50.50

Dissipatore su router d-link 2740b

Con questo post vorrei farvi vedere come fare una piccolissima mod al vostro router 2740b.

Non è una mod necessaria, il router non soffre di surriscaldamenti, ma avendo il materiale per farla… l’ho fatta!

Avevo un vecchio dissipatore per schede madri e della pasta termica collante…

La colla termica è questa:

-10pcs-lot-Heatsink-Plaster-Viscous-Thermal-Conductive-Compounds-font-b-Grease-b-font-Glue-Sticy

Costa davvero poco su eBay.

Il risultato è questo:

2012-12-30 15.14.22

 

Ovviamente, il tutto, invalida la garanzia.

Flashing SPI scheda madre asus p5b-vm

Salve

Può capitare che negli anni la vostra scheda madre possa perdere qualche colpo o che voi caricate un bios errato.

Mi è capitato, recentemente, che la mia p5b-vm aveva un serio problema di avvio: monitor nero, ventole a go-go e si spegneva inesorabilmente dopo pochi secondi.

Non l’avevo mai toccata, non ho mai messo nè mano nè saldatore… può succedere, che negli anni, che le memorie si deteriorino.

Un problema simile lo avevo sulla mitica matrox g400, una volta al mese dovevo flashare il firmware interno!

Sulle schede madri, spesso e volentieri, il bios risiede in memorie della serie 25x e che al loro fianco vi sia un connettore… il connettore spi!

Esempio:

2012-12-29 11.45.53

Come potete vedere vi è una memoria MX25 e un connettore SPI

La pedinatura del connettore è questa:

SPI header

CS# (chip select) va messo a VCC.

Fatti i debiti collegamenti col vostro programmatore siete ora in grado di: pulire la memoria, programmare un nuovo bios e verificare la scrittura.

2012-12-29 12.57.562012-12-29 12.14.382012-12-29 12.12.53

 

Usate il programmatore che volete, volendo potete usare anche la porta parallela (se esiste ancora!!!) e ricordate che questo sistema può essere utilizzato su parecchie altre schede madri

Open AirQuality System

Open AirQuality System è un sistema di monitoraggio per la qualità dell’aria che sfrutta tecnologie open hardware.

Tale progetto è stato ideato da Andrea Esposito e realizzato con l’aiuto di Fabio Giansante.

Presentato durante lo scorso Hackaton (in occasione del DevFest Campania tenutosi nella nostra università 08-07/12/2012), ha guadagnato il secondo posto.

Questo articolo, scritto a due mani, spiegherà brevemente come si compone il sistema nelle sue parti essenziali.

>>Intervista<<

 

Andrea Esposito:


Supponendo di avere alcuni tipi di sensori di gas commerciali (ad esempio: http://www.futurlec.com/Gas_Sensors.shtml), abbiamo emulato una centralina fissa che rivelava parametri chimici del tipo: co, co2, o3, NH3, NOx, CNG, h2 etc etc

Il sistema si basa sulla scheda open hardware Arduino che, configurata come data collector, raccoglie le variazioni chimiche, percepite dai sensori, trasformandole in valori numerici.

Con semplici chiamate HTTP, il modulo ethernet presente sull’arduino, riesce ad inoltrare tutti i dati ogni x secondi.

Il webservice, facendo il parsing della query string, ha il compito di raccogliere le richieste e memorizzarle su un proprio database.

Grazie a delle API scritte ad hoc, è possibile rendere fruibile all’esterno qualsiasi informazione presente nel database.

Nel nostro caso, l’app Android era in grado di selezionare un area geografica (quartiere/città) ed ottenere informazioni, in tempo reale, relativi a quell’area.

Esempio: selezionando dall’app la città di Frittole (quasi 1500) posso ottenere tutte le informazioni della qualità dell’aria relativa alla centralina installata a Frittole.

Inoltre, se il sistema fosse migliorato, ipotizzando di avere molti campioni su una popolazione di centinai di centraline sparse un pò ovunque, l’apparato potrebbe saper indicare se sul sito X c’è un anomalia in termini ambientali.

Esempio: Se a Piovarolo, nell’ultimo periodo, ho ottenuto una crescita di gas metano, probabilmente ci potrebbe esser qualche discarica abusiva di rifiuti nelle vicinanze.

Tale “popolazione di centraline” potrebbe essere installata su automobili o mezzi pubbici e, legando opportunamente le informazioni raccolte a coordinate GPS, si potrebbe estendere il monitoraggio su aree geografiche più ampie.
Legando alcuni progetti pubblicati su Sebeto (“Tutorial: data logging con Arduino”+”Tuco: Targhetta elettronica a porta con Arduino”) ho potuto prototipare un codice che mi ha permesso di emulare dati fittizzi (in modo random) e inviarli tramite comandi GET.

Nel nostro caso ho usato un oggetto String che mi ha portato via parecchia RAM (portandomi in alcuni casi ad un miserabile overflow) ma che mi ha semplificato la scrittura del codice:

String buffer="";
buffer="GET /getvalueair.json?Quartiere=Arzano&CAQ1="+(char)tempc1;
buffer+="&S02="+(char)sensore2;
buffer+="&O3="+(char)sensore3;
buffer+="&PM10="+(char)sensore4;
buffer+="&NO2="+(char)sensore5;
buffer+="&CO="+(char)sensore6;
buffer+=" HTTP/1.1";   
Serial.println(buffer); //stampa su seriale
client.println(buffer); //invio comando GET

Tale codice può essere alleggerito preferendo di gran lunga questo (da debuggare):

//    client.print("GET /getvalueair.json?Quartiere=Arzano&CAQ1=");
//    client.print(tempc1);
//    client.print("&SO2=");
//    client.print(sensore2);
//    client.print("&O3=");
//    client.print(sensore3);       //Nota: questa era l'idea originale PRIMA dell'utilizzo dell'oggetto String ma...
//    client.print("&PM10=");       //...bug 3: controllare le NewLine!!!
//    client.print(sensore4);
//    client.print("&NO2=");
//    client.print(sensore5);
//    client.print("&CO=");
//    client.print(sensore6);
//    client.println(" HTTP/1.1");

Andrea Esposito

blackstufflabs.com

 

 

 

Fabio Giansante:


FRAPI è un RESTful API Framework che permette agli sviluppatori di creare in modo semplice e rapido RESTful APIs facili da consultare e altamente performanti. FRAPI si divide in due parti specifiche: l’interfaccia di amministrazione e l’API pubblica.

admin-frapi-4

Questo particolare framework permette, con le apposite funzioni dei vari linguaggi di programmazione di cui si fa utilizzo, di leggere ed elaborare dati presenti su un server.

L’interrogazione tramite metodo GET o POST può restituire vari formati di file, uno dei più utilizzati è il file JSON.
1

Come si può notare, in questo caso, l’interrogazione restituisce una serie di dati in un unico record, ma, ovviamente, c’è anche la possibilità di avere una serie di record, ovvero un’array.

Il processo di comunicazione quindi parte dal “richiedente” (app,software, ecc..); il server, che nella maggior parte dei casi preleverà i dati da un database, restituisce una risposta.

Nel caso della nostra applicazione, possiamo evidenziare due passaggi fondamentali :

1) La centralina acquista i vari dati della qualità dell’aria e li invia al server in rete, che provvederà a memorizzarli in una database.

2) L’app ”interroga” l’apposita API che restituirà i dati tramite un file json da leggere ed elaborare.

Uno dei principali vantaggi di una tale infrastruttura è che non c’è tantissimo codice da scrivere.

Tralasciando la parte relativa alla grafica (layout, immagini, bottoni ecc), per elaborare il file JSON, bastano davvero poche righe di codice :

2

La parte fondamentale è nelle prime tre righe, dove :

– la variabile “url” è l’indirizzo tramite il quale si ricava il file JSON

– la funzione “readJSON” prende in input l’url e esegue una sorta di “scansione” del file JSON

– “JSONObject jso” istanzia un oggetto di tipo JSON da poter elaborare

– per effettuare l’elaborazione, bisogna conoscere i vari nomi dei campi che compongono il record, in questo caso vediamo che con la funzione “jso.getString(“Quartiere”)” si estrapola un campo di tipo string identificato col nome “Quartiere”.

L’applicazione android Open AirQuality System potenzialmente potrebbe diventare un utilissimo servizio pubblico a disposizione dei cittadini. La prospettiva di funzionamento è molto semplice e la descriviamo tramite un esempio :

Il sign. Mario Rossi vive nei pressi del Centro Direzionale; ha deciso che è giunto il momento di fare un po’ di footing, ma il suo medico curante gli ha vivamente consigliato di praticarlo quando il livello di CO2 (anidride carbonica) nell’aria è davvero minimo. Bene, il sign. Rossi allora attiva l’app. che localizza la sua posizione tramite gps e mostra in tempo reale i vari parametri della qualità dell’aria nella zona localizzata, in modo tale da poter decidere se è opportuno o meno scendere.

1

C’è inoltre la possibilità di poter scegliere, mediante una select, tra i vari quartieri “sotto-analisi”, in modo tale che se a Capodimonte o altrove i valori sono ottimali, il sign. Rossi può decidere dove è più opportuno svolgere la sua attività fisica.

Fabio Giansante

0124/0028

fabio.giansante@studenti.uniparthenope.it

Arduino: Lettore universale di API

Con questo articolo vorrei mostrarvi i rudimenti per visualizzare su display i risultati di qualsiasi API-REST.

In particolare la visualizzazione delle API Weather di Salvatore Serafino.

Il codice è quasi identico  a quello per la bacheca elettronica “tuco”, per questo motivo credo che modificando opportunamente il firmware possiamo dire che è “universale”.

Il problema del buffer:

Risposte GET molto grandi (molti caratteri) implicano l’uso di buffer molto grandi che manderebbero in overflow il microcontroller senza visualizzare nulla (se ci va bene!).

In questo caso la risposta è memorizzata in un buffer poco più grande di 305 char.

305 char sono 305byte in memoria  (cira 0.3kb).

Sarebbe stato un lavoro più pulito se avessi utilizzato librerie che gestiscono file json; per arduino ho trovato questa: https://github.com/interactive-matter/aJson

Le domande da porci ogni volta sono:

Vale davvero la pena immergere nel proprio binario un’altra libreria a scapito della memoria flash?

Quanta ram avrebbe utilizzato?

La RAM dell’atmega328 (arduino uno/duemilanove) è da 2kb (due cappa, non otto giga!), utilizzata non solo per il buffer…

Seppur il codice viene ottimizzato dal compilatore avr-gcc è buona norma non affaticare il controller che lavoro a soli 16MHz (mega non giga! “single core”!).

Infatti è raro trovare codici che fanno uso di allocazione dinamica, strutture dati complesse ed oggetti avanzati: la StandardTemplateLibrary è ridotta all’osso.

La memoria flash è di soli 32Kb, ed è consigliabile non includere troppe librerie.

Questo codice porta via circa 19kb di flash memory.

Per arginare questi problemi bisogna demandare il carico di lavoro al server.

L’ideale sarebbe: tante GET ben parametrizzate che restituiscono piccole informazione per piccoli buffer.

Ecco perché le api dovrebbero essere ben parametrizzare per restituire poca roba!

Dopo questa piccola premessa analizziamo tutte le fasi della produzione:

HW:

L’hardware che ho usato è sempre lo stesso: router, ethernet shield, arduino duemilanove e un lcd 16×2 seriale.

Questa volta ho utilizzato un lcd più piccolino ma con meno ingombro di cavetterie: solo 4 fili!

Per la precisione vengono utilizzati due cavi (data e clock) per il bus seriale i2c e due cavi per l’alimentazione (+5v e gnd).

Non è il massimo per la lettura ma per la prototipazione rapida è un must.

Documentazione e wiring: http://learn.adafruit.com/i2c-spi-lcd-backpack

Librerie extra:

Per pilotare il convertitore seriale-i2c ho utilizzato la libreria LiquidCrystal ottimizzata da Adafruit: https://github.com/adafruit/LiquidCrystal

Inizializzazione:

viene fatta nella void function setup() e consiste nell’invocazione dei seguenti metodi:

lcd.begin(16, 2); //inizializzazione del display 16x2
Serial.begin(9600);//inizializzazione della porta seriale a 9600baud
Ethernet.begin(mac);//inizializzazione della scheda Ethernet con il proprio mac

La struttura del loop():

myConnect() connessione al server
esecuzione del comando GET
parse() lettura e memorizzazione della risposta in un buffer
disconnect() disconnessione dal server
stampa() parsing del buffer
stampa del buffer su lcd

 

 

 

 

Demando tutti i dettagli implementativi nei commenti del codice.

Codice:

Api-Photo-courtesy-mammedomani.it_

Video:

 

Tutorial: come formattare il codice

Salve

Con questo tutorial vorrei mostrarvi come pubblicare post sui vostri blog con codice leggibile e *sfizioso* da vedere.

Prima di tutto, (se non lo avete fatto) indentiamo tutto come si deve: copiamo la porzione di codice che ci interessa, diamola in input ad uno di questi tool online ed indentiamo.

Indenter:

http://www.prettyprinter.de/

http://jsbeautifier.org/

http://indentcode.net/

Fatto ciò, ricopiamo il codice correttamente indentato, e diamolo in pasto a questo tool:

Syntax Highlighter: http://markup.su/highlighter/

Scegliamo il tipo di linguaggio di programmazione ed una combinazione di colori a piacere; cliccate su Highligh e dopo su “copy to clipboard”.

Avete così, del codice html che formatta e colora il vostro codice!

Esempio:

PRIMA

(solo con il tag <pre>)

/*
  Blink
  Turns on an LED on for one second, then off for one second, repeatedly.

  This example code is in the public domain.
 */

// Pin 13 has an LED connected on most Arduino boards.
// give it a name:
int led = 13;

// the setup routine runs once when you press reset:
void setup() {                
  // initialize the digital pin as an output.
  pinMode(led, OUTPUT);     
}

// the loop routine runs over and over again forever:
void loop() {
  digitalWrite(led, HIGH);   // turn the LED on (HIGH is the voltage level)
  delay(1000);               // wait for a second
  digitalWrite(led, LOW);    // turn the LED off by making the voltage LOW
  delay(1000);               // wait for a second
}

DOPO

/*
  Blink
  Turns on an LED on for one second, then off for one second, repeatedly.

  This example code is in the public domain.
 */

// Pin 13 has an LED connected on most Arduino boards.
// give it a name:
int led = 13;

// the setup routine runs once when you press reset:
void setup() {                
  // initialize the digital pin as an output.
  pinMode(led, OUTPUT);     
}

// the loop routine runs over and over again forever:
void loop() {
  digitalWrite(led, HIGH);   // turn the LED on (HIGH is the voltage level)
  delay(1000);               // wait for a second
  digitalWrite(led, LOW);    // turn the LED off by making the voltage LOW
  delay(1000);               // wait for a second
}
/*
  Blink
  Turns on an LED on for one second, then off for one second, repeatedly.

  This example code is in the public domain.
 */

// Pin 13 has an LED connected on most Arduino boards.
// give it a name:
int led = 13;

// the setup routine runs once when you press reset:
void setup() {                
  // initialize the digital pin as an output.
  pinMode(led, OUTPUT);     
}

// the loop routine runs over and over again forever:
void loop() {
  digitalWrite(led, HIGH);   // turn the LED on (HIGH is the voltage level)
  delay(1000);               // wait for a second
  digitalWrite(led, LOW);    // turn the LED off by making the voltage LOW
  delay(1000);               // wait for a second
}
/*
  Blink
  Turns on an LED on for one second, then off for one second, repeatedly.

  This example code is in the public domain.
 */

// Pin 13 has an LED connected on most Arduino boards.
// give it a name:
int led = 13;

// the setup routine runs once when you press reset:
void setup() {                
  // initialize the digital pin as an output.
  pinMode(led, OUTPUT);     
}

// the loop routine runs over and over again forever:
void loop() {
  digitalWrite(led, HIGH);   // turn the LED on (HIGH is the voltage level)
  delay(1000);               // wait for a second
  digitalWrite(led, LOW);    // turn the LED off by making the voltage LOW
  delay(1000);               // wait for a second
}
/*
  Blink
  Turns on an LED on for one second, then off for one second, repeatedly.

  This example code is in the public domain.
 */

// Pin 13 has an LED connected on most Arduino boards.
// give it a name:
int led = 13;

// the setup routine runs once when you press reset:
void setup() {                
  // initialize the digital pin as an output.
  pinMode(led, OUTPUT);     
}

// the loop routine runs over and over again forever:
void loop() {
  digitalWrite(led, HIGH);   // turn the LED on (HIGH is the voltage level)
  delay(1000);               // wait for a second
  digitalWrite(led, LOW);    // turn the LED off by making the voltage LOW
  delay(1000);               // wait for a second
}
/*
  Blink
  Turns on an LED on for one second, then off for one second, repeatedly.

  This example code is in the public domain.
 */

// Pin 13 has an LED connected on most Arduino boards.
// give it a name:
int led = 13;

// the setup routine runs once when you press reset:
void setup() {                
  // initialize the digital pin as an output.
  pinMode(led, OUTPUT);     
}

// the loop routine runs over and over again forever:
void loop() {
  digitalWrite(led, HIGH);   // turn the LED on (HIGH is the voltage level)
  delay(1000);               // wait for a second
  digitalWrite(led, LOW);    // turn the LED off by making the voltage LOW
  delay(1000);               // wait for a second
}