Ho avuto modo di provare una scheda Particle Photon, un modulo programmabile con WiFi, che ha la caratteristica principale di essere programmabile via Cloud con una interfaccia Web. Il prezzo attuale e' circa sui 19 dollari (spedizione esclusa)
Il processore e' un ARM Cortex M3 con un 1Mb di memoria flash e 128 Kb di ram con sistema operativo FreeRTOS
La scheda e' estremamente piccola (pesa sui 5 grammi ed ha dimensioni di 36.5x20.3x6.8 mm, vedi per confronto la breadboard) e puo' essere alimentata da Usb oppure da VIN con un intervallo da 3.6 a 5.5 V
 |
| Immagine ufficiale dal sito del produttore |
Si puo' derivare corrente dal pin 3V3 (3.3 V) oppure dal VIN (4.8 V/1A)
Il consumo dichiarato e' di 80 mA ma nelle mie prove ho visto un valore medio di 40 mA (con trasmittente accesa)
Sono disponibili 7 pin analogici con un ADC a 12 bit (come Arduino Due), una seriale TTL e 7 pin GPIO digitali
La programmazione avviene puntando il browser su
https://build.particle.io e selezionando il proprio dispositivo.
Si programma in modo molto simile ad una Arduino e per caricare lo sketch sulla scheda si preme il pulsante del fulmine. Visto che tutto avviene via rete non e' necessario nessun cavo di collegamento dati e non e' nemmeno necessaria la vicinanza fisica (io la prova l'ho effettuato programmando da remoto senza averla nemmeno mai vista direttamente)
L'aspetto forse piu' interessante e' che le variabili (per esempio la lettura di un sensore) si possono effettuare direttamente via cloud. Non e' necessario conoscere l'IP della Photon e non e' necessario smanettare sul router per le regole delle porte del firewall
se nello sketch si inserisce una riga del tipo
Spark.variable("volts_x", &volts_x, DOUBLE);
il valore di questa variabile sara' disponibile all'indirizzo (con servizio REST)
https://api.particle.io/v1/devices/ID_PHOTON/volts_x?access_token=ACCESS_TOKEN
dove si deve sostituire a ID_PHOTON una stringa alfanumerica di 24 caratteri identificativa del dispositivo mentre ACCESS_TOKEN e' una stringa di 40 caratteri (entrambe si recuperano dall'interfaccia web cliccando nella colonna a sinistra in basso sul simbolo del mirino (Devices) per ID_PHOTON e su Settings per l'ACCESS_TOKEN
La risposta del sito e' qualcosa di questo tipo (il valore della variabile nel campo result)
--------------------------------------------------------------------------------
{
"cmd": "VarReturn",
"name": "volts_x",
"result": 2.0012695312499997,
"coreInfo": {
"last_app": "",
"last_heard": "2015-11-13T09:19:34.112Z",
"connected": true,
"last_handshake_at": "2015-11-13T09:19:02.262Z",
"deviceID": "430024000e47343233323032",
"product_id": 6
}
}
--------------------------------------------------------------------------------
Un altro vantaggio dell'approccio Cloud e' che si puo' ospitare una pagina Web su un IP pubblico e gestire tutti i sensori con indirizzi su rete privata
Dato che le informazioni passano via Cloud non e' possibile avere un refresh estramamente veloce (nelle prove e' stato chiaro che scendere sotto 1Hz di refresh dei dati era molto difficile)
Per provare la Photon ho collegato un Breakout ADXL335 di Sparkfun, accelerometro in uscita analogica, che e' settato per avere un passo di campionamento di 50 Hz (sono gia' presenti condensatori da 10 microFarad) con misure +/- 3g. Visto che e' stato alimentato a 3.3V la conversione tra V e g e' pari a 330mV/g. Quindi ad accelerazione zero viene letto un valore in tensione pari 1.65 v (3.3V/2). Effettuando la sottrazione tra il valore letto e 1.65 V ed effettuando la conversione si ha il valore in accelerazione g
Il consumo dell'ADXL335 e' di circa 375 microAmpere
Attenzione : la sensibilita' e' differente sui vari assi. Su X e Y sono significative fino al centesimo di g mentre su Z e' significativo il decimo di g
 |
|
|
Utilizzando questa pagina (modificata da un esempio trovato in rete)
-----------------------------------------
| <html> |
| <head> |
| <script src="http://ajax.googleapis.com/ajax/libs/jquery/1.7.2/jquery.min.js" type="text/javascript" charset="utf-8"></script> |
| <script src="raphael-2.1.4.min.js"></script> |
| <script src="justgage-1.1.0.min.js"></script> |
| <script> |
| var accessToken = "INSERIRE ACCESS TOKEN"; |
| var deviceID = "INSERIRE DEVICE ID" |
| |
|
|
| var url_x = "https://api.spark.io/v1/devices/" + deviceID + "/volts_x"; |
| var url_y = "https://api.spark.io/v1/devices/" + deviceID + "/volts_y"; |
| var url_z = "https://api.spark.io/v1/devices/" + deviceID + "/volts_y"; |
|
|
| function callback_x(data, status){ |
| if (status == "success") { |
| volts_x = parseFloat(data.result); |
| g.refresh(volts_x); |
| setTimeout(getReading_x, 50); |
| } else { |
| alert("There was a problem"); |
| } |
| } |
|
|
| function callback_y(data, status){ |
| if (status == "success") { |
| volts_y = parseFloat(data.result); |
| g2.refresh(volts_y); |
| setTimeout(getReading_y, 50); |
| } else { |
| alert("There was a problem"); |
| } |
| } |
|
|
| function callback_z(data, status){ |
| if (status == "success") { |
| volts_z = parseFloat(data.result); |
| g3.refresh(volts_z); |
| setTimeout(getReading_z, 50); |
| } else { |
| alert("There was a problem"); |
| } |
| } |
|
|
| function getReading_x(){ |
| $.get(url_x, {access_token: accessToken}, callback_x); |
| } |
| function getReading_y(){ |
| $.get(url_y, {access_token: accessToken}, callback_y); |
| } |
| function getReading_z(){ |
| $.get(url_z, {access_token: accessToken}, callback_z); |
| } |
|
|
|
|
| </script> |
| </head> |
| <body> |
| <table><tr> |
| <td><div id="gauge_x" class="200x1600px"></div></td> |
| <td><div id="gauge_y" class="200x160px"></div></td> |
| <td><div id="gauge_z" class="200x160px"></div></td> |
| </tr></table> |
|
|
| <script> |
| var g = new JustGage({ |
| id: "gauge_x", |
| value: 0, |
| min:-3.0, |
| max: 3.0, |
| title: "Acc. Z(g)", |
| decimals : 2 |
| }); |
| getReading_x(); |
|
|
| </script> |
|
|
| <script> |
| var g2 = new JustGage({ |
| id: "gauge_y", |
| value: 0, |
| min: -3.0, |
| max: 3.0, |
| title: "Acc. Y(g)", |
| decimals : 2 |
| }); |
| getReading_y(); |
| </script> |
|
|
| <script> |
| var g3 = new JustGage({ |
| id: "gauge_z", |
| value: 0, |
| min: -3.0, |
| max: 3.0, |
| title: "Acc. X(g)", |
| decimals : 2 |
| }); |
| getReading_z(); |
| |
| </script> |
| </body> |
| </html> |
-----------------------------------------
Si puo' avere una lettura dei valori di accelerazione mediante Photon su Web
(ovviamente l'asse Z misura l'accelerazione di gravita' e quindi non e' zero, il valore dovrebbe essere piu' vicino ad 1, forse c'e' da rivedere il fattore di conversione)
Essendo una visualizzazione via Web il refresh dei dati e' piuttosto lento e lontano dalla frequenza di 50 Hz. In Javascript ho impostato un valore di lettura ogni 50 millisecondi ma aprendo in Chrome Strumenti per sviluppatori/Network si vede chiaramente che vengono impiegati dai 350 ai 500 ms per ogni transazione web (quindi un campionamento intorno a 2-3 Hz)
Una ultima considerazione : come "brand" scegliere Photon e Particle come nomi non e' che sia proprio un colpo di genio. Cercando sui motori di ricerca "Photon Particle" per ottenere informazioni su questo dispositivo saltano fuori seriosissimi articoli di fisica e non quanto desiderato
