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:

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

La pedinatura del connettore è questa:

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.

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

Lascia una risposta

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: https://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.

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.

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 :

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.

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

Lascia una risposta

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: https://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:

Video:

Tutorial: come formattare il codice

Lascia una risposta

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:

https://www.prettyprinter.de/

https://jsbeautifier.org/

https://formatter.org/

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
}

Tuco: Targhetta elettronica a porta con Arduino

Lascia una risposta

Tuco 1.0 è una targhetta elettronica a porta: “intelligente”, open source e open hardware.

E’ stata concepita per essere installata (teoricamente) sulle porte degli studi della nostra università.

Lo scopo della targhetta è visualizzare in tempo reale informazioni del tipo: numero dello studio, docente/i, orari di ricevimento, contatti mail e/o telefonici etc etc… ma soprattutto avvisi presi in tempo reale da uno dei canali di comunicazione dell’università.

E’ stata realizzata sfruttando l’hardware del famoso progetto 100% Italiano chiamato “Arduino“.

Questo prototipo in particolare usa: Arduino Duemilanove, Ethernet Shield, un router (modificato) WiFi Fonera 2100 e un display grafico (G-LCD) parallelo KS0107

Quindi da oggi, le targhette stampate sulle porte della nostra università, potrebbero trasformarsi da queste:

A qualcosa di molto simile a questa:

Come è stato realizzato questo progetto?

Parte hardware:

Dopo aver configurato le impostazioni del firmware DD-WRT (open) correttamente, il nostro router Fonera deve collegarsi alla propria rete WiFi in modalità repeater WiFi (una valida alternativa della Fonera è il TL-WR702N)

Il router andrà collegato all’ethernet shield con un normale cavo RJ45

Il wiring fatto tra GLCD e Arduino si può trovare sulla documentazione ufficiale della librearia grafica GLCD per Arduino: https://github.com/OkbaO/KS0108_LCD

Avendo l’accortezza, però, di cambiare i pin:

GLCD – ARDUINO

9 -> D2
10 -> D3

16 -> A1

15 -> A2

Per poi ottenere questo:

Parte software:

Dopo aver scaricato e configurato la propria Arduino IDE, bisogna scaricare ed installare nel path giusto la libreria grafica GLCD.

All’interno della libreria grafica GLCD vanno modificato alcuni file in questo modo:

In: glcd/glcd_Config.h

Bisogna: commentare #include “config/ks0108_Panel.h” e togliere il commento da //#include “config/ks0108_Manual_Config.h”

In: glcd/config/ks0108_Manual_Config.h

Bisgona: modificare la linea

#define glcdData2Pin        10
#define glcdData3Pin        11

#define glcdData2Pin        2
#define glcdData3Pin        3

Save & exit.

Questa modifica è necessaria in quanto sia l’etherne shield che il glcd hanno in comune i pin 10 e 11, dunque per evitare incompatibilità tra i due hardware, la libreria va modificata come sopra

Il firmware:

Il firmware, da me scritto, è presente nella mia cartella personale su: cliccami

Circa i punti salienti del firmware, posso aggiungere che la funzione principale loop (un loop infinito) è strutturata quanto segue:

void loop() { 
  logo();
  cornice();
  numero();
  mail();
  myConnect();
  parse();
  disconnect();
}

In particolare:

Logo

è una funzione che restituisce due immagini bitmap, opportunamente realizzate con un tool (in java e open) all’interno della libreria grafica glcd.

In particolare restituisce il logo della nostra università diviso in due metà.

Cornice

Grazie all’uso dell’oggetto gText ho strutturato il display in tre parti:

Questo mi permette di avere le informazioni divise per aree grafiche tematiche:

Nella superiore visualizzo nome e cognome del/dei docenti e numero dello studio.

Al centro tutte le informazioni DINAMICHE

Nella parte inferiore l’orario di ricevimento

numero e mail

Sono due funzioni che stampano sul gText.centrale rispettivamente: numero stanza e l’indirizzo email.

myConnect

E’ la funzione che mi permette di instaurare un collegamento in modalità client, tra la mia arduino ed il server sebeto.

In particolare myConnect cerca di instaurare il collegamento, ma se dopo tre tentativi non riesce a stabilire una connessione, avviene un hardreset grazie alla macro definita nell’header del firmware.

Una volta stabilita la connessione, effettuo il comando GET verso l’api news (settata in modo tale da restituire un solo avviso)

parse

E’ la funzione che realizza il parsing del primo avviso restituito dall’api news, in particolare cerca la sottostringa content e memorizza il contenuto dei primi 300caratteri in un buffer.

Il buffer viene stampato char by char con un ritardo di 50ms tra un char e l’altro.

disconnect

realizza la disconnessione dell’arduino dal server.

Note finali:

Non avendo un sistema di avvisi centralizzato e comune, in questo prototipo, è stato utilizzato l’api news a scopo dimostrativo.
Se avessimo un sistema di avvisi centralizzato si potrebbe modificare il firmware in questo modo:

una query join tra il numero di porta a cui è stato assegnato l’arduino e il DB dei docenti
la query potrebbe restituire molte informazioni, ad esempio: nome, cognome, email, telefono etc etc
il primo/i avviso di ogni docente di quello studio
print delle informazioni scelte su glcd

Il limite degli avvisi in questo prototipo, è stato fissato a 300 per ragioni di memoria, leggibilità e perchè fa più figo pensare gli avvisi come dei tweet
Essendo open source, ogni idea e modifica è facilmente realizzabile
Nel video il display sembra rovinato o sbiadito: è un effetto dovuto ai filtri video di YouTube.
Eventuali combinazioni hardware possono essere:

Router -> Ethernet Shield -> Arduino -> Glcd (è il mio prototipo)
Router -> Arduino Ethernet -> Glcd
Arduino WiFi Shield -> Arduino -> GLCD
Arduino + WiFi (su singola pcb) -> Glcd (la combinazione migliore per spazio)

Alcune foto:

Tuco 1.0 firmware

Indicatore gpl v1

2 Repliche

Finalmente ho trovato un pò di tempo e il materiale giusto!
Ho collegato un piccolo display a 7 segmenti / voltimetro che indica esattamente il valore in volts del sensore di quantità di gpl del ruotino.
Funziona davvero bene, l’unica particolarità è che nei momenti in cui l’auto è un sballottolata (accellerate, fossi, dossi, curve) il valore cambia di un bel pò.

L’ideale sarebbe installare un arduino con display bello grosso, in modo tale da indicare tanti valori ad esempio: km percorsi, km parziali, km al litro con gas etc etc

Per ora posto le foto del mio piccolo progetto.

Da notare che:
1. ho installato un piccolo switch nascosto, nel caso in cui mia sia stufato di vedere il display acceso lo spengo
2. il display si accende solo quando si gira l’auto

Italian Maker Blog

Personal blog about DIY and embedded systems.

Flashing SPI scheda madre asus p5b-vm

Open AirQuality System

>>Intervista<<

Arduino: Lettore universale di API

Dopo questa piccola premessa analizziamo tutte le fasi della produzione:

Tutorial: come formattare il codice

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

Esempio:

PRIMA

DOPO

Tuco: Targhetta elettronica a porta con Arduino

Come è stato realizzato questo progetto?

Parte hardware:

Parte software:

Il firmware:

Note finali:

Tuco 1.0 firmware

Indicatore gpl v1