Intel Edison e Xbee

Connettere una Intel Edison ha una rete Xbee e' piuttosto semplice ed automatico
Dopo aver montato uno shield Arduino Xbee con il relativo modulo radio (gia' programmato) si invieranno e riceveranno i dati sulla connessione seriale /dev/ttyMFD1 (che di fatto cortocircuita i pin Rx/Tx 0 ed 1 di Arduino verso Yocto)

Programmare Arduino Expansion Board su Intel Edison

Edison Intel non e' una vera Arduino (nel senso che non monta un microcontrollore ATMEGA328) ma ha comunque un buon grado di compatibilita' anche per gli shield Arduino

Per la programmazione dei pin Arduino si puo' utilizzare Python o C++ mediante la libreria MRAA ed UPM

Blink led con Python
-----
 import mraa
 led = mraa.Gpio(13)
 led.dir(mraa.DIR_OUT)
led.write(1)
led.write(0)
exit()

-----

Lettura della porta analogica 0

-----

import mraa 

porta = mraa.Aio(0)
while 1: 

     valore = float(pot.read())

     print valore

-----

usando la libreria UPM sono gia' disponibili molti esempi su diversi sensori a questo indirizzo

Si puo' utilizzare anche Arduino IDE per controllare i pin. In questo caso si deve in modo preliminare configurare la scheda andando in Strumenti/Scheda/Gestore Schede installando Intel i686 Boards (Edison)

Utilizzando Arduino IDE l'upload degli sketch avviene in modo tradizionale. L'unica differenza fondamentale e' che gli sketch vengono salvati in /tmp per cui al successivo riavvio non sara'  piu ' disponibile. Per ovviare a questo problema si deve procedere come

cp /tmp/nome_sketch /sketch/sketch.elf
chmod 755 /sketch.sketch.elf

L'Expansion Board puo' essere programmata anche tramite C/C++. Per fare cio' si usa Intel System Studio IoT Edition (sostanzialmente una versione modificata di Eclipse)


Per lanciare il programma si usa ./iss-iot-launcher

Di fatto si tratta di programmazione remota perche' il file viene compilato sul PC e poi inviato ed eseguito sulla Edison via SSH (WiFi, Ethernet-over-Usb). Si deve quindi, prima di procedere, creare una connessione con Edison

I file compilati vengono copiati sulla /tmp di Edison. Per questo motivo non saranno disponibili dopo un riavvio a meno di non  copiare il file eseguibile in un'altra posizione

Blink in C++
----------------------------------------------
/*
 * Author: Jessica Gomez <jessica.gomez.hernandez@intel.com>
 * Copyright (c) 2015 - 2016 Intel Corporation.
 *
 * Permission is hereby granted, free of charge, to any person obtaining
 * a copy of this software and associated documentation files (the
 * "Software"), to deal in the Software without restriction, including
 * without limitation the rights to use, copy, modify, merge, publish,
 * distribute, sublicense, and/or sell copies of the Software, and to
 * permit persons to whom the Software is furnished to do so, subject to
 * the following conditions:
 *
 * The above copyright notice and this permission notice shall be
 * included in all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
 * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
 * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
 * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 */

#include "mraa.h"

#include <stdio.h>
#include <unistd.h>

/*
 * On board LED blink C example
 *
 * Demonstrate how to blink the on board LED, writing a digital value to an
 * output pin using the MRAA library.
 * No external hardware is needed.
 *
 * - digital out: on board LED
 *
 * Additional linker flags: none
 */

int main()
{
// select onboard LED pin based on the platform type
// create a GPIO object from MRAA using it
mraa_platform_t platform = mraa_get_platform_type();
mraa_gpio_context d_pin = NULL;
switch (platform) {
case MRAA_INTEL_GALILEO_GEN1:
d_pin = mraa_gpio_init_raw(3);
break;
case MRAA_INTEL_GALILEO_GEN2:
d_pin = mraa_gpio_init(13);
break ;
case MRAA_INTEL_EDISON_FAB_C:
d_pin = mraa_gpio_init(13);
break;
default:
fprintf(stderr, "Unsupported platform, exiting");
return MRAA_ERROR_INVALID_PLATFORM;
}
if (d_pin == NULL) {
fprintf(stderr, "MRAA couldn't initialize GPIO, exiting");
return MRAA_ERROR_UNSPECIFIED;
}

// set the pin as output
if (mraa_gpio_dir(d_pin, MRAA_GPIO_OUT) != MRAA_SUCCESS) {
fprintf(stderr, "Can't set digital pin as output, exiting");
return MRAA_ERROR_UNSPECIFIED;
};

// loop forever toggling the on board LED every second
for (;;) {
mraa_gpio_write(d_pin, 0);
sleep(1);
mraa_gpio_write(d_pin, 1);
sleep(1);
}

return MRAA_SUCCESS;
}

----------------------------------------------

Node.JS

nonostante sia possibile programmare Edison con Node:JS non sono riuscito a far funzionare XKD Iot su Centos. Si puo' comunque usare Node. direttamente da shell senza usare la programmazione remota

Blink led con Node.JS
-----
var mraa = require('mraa'); 

console.log('MRAA Version: ' + mraa.getVersion());

var myOnboardLed = new mraa.Gpio(13); 

myOnboardLed.dir(mraa.DIR_OUT); 

-----

Lettura della porta analogica 0

-----

var mraa = require('mraa'); 

console.log('MRAA Version: ' + mraa.getVersion()); 

var analogPin0 = new mraa.Aio(0); 

var analogValue = analogPin0.read(); 

console.log(analogValue);

-----

Ethernet-over-USB per Intel Edison su Linux

La Intel Edison oltre alla connessione della consolle via Seriale e via WiFi dispone anche della possibilita' di stabilitre una connessione TCP anche via cavo Usb con il protocollo Ethernet-over-USB (su Windows prende il nome del protocollo proprietario RNDIS)

Se si collega Edison con la porta USB-OTG e si digita sul Pc il comando
ip a

si ottiene un nuovo dispositivo che nel mio caso specifico e' enp0s26u1u1uc2.
Intel Edison ha un Ip statico sulla connessione USB (192.168.2.15). Per ottenere una connessione SSH via USB e' sufficiente impostare l'ip della connessione lato PC con

ifconfig enp0s26u1u1uc2 192.168.2.2

a questo punto si puo' lanciare la sessione ssh con
ssh root@192.168.2.15

questa configurazione puo' essere utile nel caso si voglia programmare il dispositivo utilizzando iss-iot-linux (l'ambiente di sviluppo Linux/Eclipse per Edison) senza la necessita' di attivare un access point

Flash firmware su Intel Edison

E' passato un paio di settimane che gioco con Intel Edison e sono gia' nella necessita' di flashare il firmware (cercando di installare un dongle USB-Ethernet ho incasinato la connessione WiFi)

Per ripristinare il sistema operativo di Edison si parte scaricando il file
iot-devkit-prof-dev-image-edison-2010606.zip

p
Prima di procedere oltre si deve installare il programma dfu-util.
La sequenza e' la seguente

git clone git://git.code.sf.net/p/dfu-util/dfu-util
cd dfu-util
./autogen.sh
./configure
make
make install

a questo punto si puo' lanciare il file ./flash_all.sh

Si vedono scorrere i seguenti messaggi (il tempo e' di circa 5 minuti)
------------------------------------------------------
[root@localhost immagine]# ./flashall.sh
Using U-Boot target: edison-blankcdc
Now waiting for dfu device 8087:0a99
Please plug and reboot the board
Flashing IFWI
Download    [=========================] 100%      4194304 bytes
Download    [=========================] 100%      4194304 bytes
Flashing U-Boot
Download    [=========================] 100%       237568 bytes
Flashing U-Boot Environment
Download    [=========================] 100%        65536 bytes
Flashing U-Boot Environment Backup
Download    [=========================] 100%        65536 bytes
Rebooting to apply partition changes
Now waiting for dfu device 8087:0a99
Flashing boot partition (kernel)
Download    [=========================] 100%      6144000 bytes
Flashing rootfs, (it can take up to 5 minutes... Please be patient)
Download    [=========================] 100%   1373149184 bytes
Rebooting
U-boot & Kernel System Flash Success...
Your board needs to reboot to complete the flashing procedure, please do not unplug it for 2 minutes.

------------------------------------------------------

Al reboot si collega il cavo USB alla porta seriale per ottenere una consolle

screen /dev/ttyUSB1 115200

(per terminare una connessione screen CTRL+A CTRL+D)

di default l'utente root non ha password. Al login basta digitare root e si entra in shell
Per ottenere la connessione SSH si deve prima configurare la password del dispositivo con

configure-edison --password

a questo punto si configura la connessione WiFi con
configure-edison --wifi

il dispositivo, oltre all'Ip, puo' essere anche richiamato come edison.local

per terminare e' sufficiente installare gli aggiornamenti di sistema

opkg update
opkg upgrade

Facendo cio' si genera il seguente errore
Failed to download http://iotdk.intel.com/repos/3.5/intelgalactic/opkg/i586//Packages

l'errore e' generato dal fatto che la directory non esiste: Guardando al sistema precedente (il 3.0) nella directory http://iotdk.intel.com/repos/3.0/intelgalactic/opkg/i586/ sono contenuti gli aggiornamenti per la libreria mraa e upm ma questi nel sistema 3.5 sono contenuti in http://iotdk.intel.com/repos/3.5/iotdk/edison/core2-32/

Per questo motivo credo si tratti solo di un refuso nel file dei repository nel passaggio da 3.0 a 3.5

Windows 10 Update: Connettivita' limitata su WiFi

Dopo un corposo aggiornamento di Windows 10 (tanto corposo che ho lasciato il calcolatore acceso di notte in attesa del termine) mi sono trovato il giorno successivo con il messaggio di Connettivita' Limitata sulla rete WiFi (il che tradotto vuol dire che il Pc si era collegato all'Access Point ma non era in grado di raggiungere Internet)

L'aggiornamento era stato via WiFi quindi la rete senza fili funzionava. Usando un Surface (hardware Microsoft) mi sono dovuto attrezzare con un dongle Usb-Ethernet per riguadagnare Internet e vedere se c'erano ulteriori aggiornamenti in attesa di installazione. Dopo un altro corposo aggiornamento la situazione e' rimasta identica...niente connessione via WiFi.

Questo problema era segnalato da altri utenti ma erano situazioni legate a upgrade da Windows 8 a Windows 10...quindi non il mio caso

La soluzione e' stata quella di ripristinare il driver della scheda di rete senza fili.
Certo che se Windows non funziona nemmeno su hardware Microsoft......

Webcam su Intel Edison

Il primo passo per utilizzare una webcam su Intel Edison e' quella di spostare il selettore SW2 dalla parte della porta USB standard. In questo  modo si disattiva la porta microUsb OTG e si attiva la porta USB standard

Dal punto di vista dei moduli del kernel la mia Logitech C310 e' stata vista senza troppi problemi e montata in /dev/video0

Partendo dai repositori dai repository di AlexT (vedi qui) e' banale installare motion 

motion in azione

Piu' problematico invece far funzionare mjpeg-streamer. Scaricando via opkg da AlexT il pacchetto risulta andare in segmentation fault. Ho provato a ricompilare quindi dai sorgenti (l'ultima versione disponibile e' la r63) risolvendo le dipendenze e quindi installando anche v4l-utils.

In fase di compilazione pero' mjpeg-streamer si e' rifiutato per un errore piuttosto criptico su un plugin, penso dovuto al fatto che io ho installato v4l2 mentre mpjeg-streamer usa v4l.

Frugando su github ho trovato v4l2_mjpeg_streamer, una versione alleggerita di mjpeg_streamer basata su v4l2 che permette una trasmissione a 5 fotogrammi per secondo alla massima risoluzione della camera (al contrario di mjpeg_streamer la porta TCP e' la 8081)

Accuratezza di sensore ultrasonico SR-04

Per un lavoro di laboratorio e' necessario misurare la distanza di un campione senza toccarlo con un comparatore. Per questo motivo e' stata provato ad usare il sensore ultrasonico SR-04 come misuratore di distanza
La precisione richiesta era di 1 mm mentre le schede tecniche che si trovano su Internet parlano di un valore minimo di risoluzione di 3 mm..in ogni caso e' stata fatta una prova

Il bersaglio era costituito da una lamina di alluminio e il sensore e' stato collegato ad una Arduino Uno. Purtroppo non e' stato possibile mettere su un sistema che permetteva la perfetta ortogonalita' della sensore emittente con la superficie riflettente (questo e' un limite della presente misura)

Visto che il sensore non misura direttamente la distanza ma il tempo di volo di un impulso (la distanza si calcola a ritroso conoscendo la velocita' del suono nell'aria) e visto che la velocita' del suono nell'aria e' funzione della temperatura (e non della pressione) secondo un legge del tipo

velocita'_suono=331.4+0.62*temperatura (m/sec)

ho misurato il tempo di volo tramite la libreria NewPing spostando il bersaglio posto a distanza variabile intorno ai 20 cm, Per ogni posizione sono state effettuate 500 acquisizione che poi sono state mediate mediante la libreria Statistics di Arduino

(di seguito si usa il simbolo ms per indicare i microsecondi)

Lo sketch impiegato e' stato il seguente

------------------------------------------------

#include <NewPing.h>
#include "Statistic.h" 

#define TRIGGER_PIN  12  // Arduino pin tied to trigger pin on the ultrasonic sensor.
#define ECHO_PIN     11  // Arduino pin tied to echo pin on the ultrasonic sensor.
#define MAX_DISTANCE 50 // Maximum distance we want to ping for (in centimeters). Maximum sensor distance is rated at 400-500cm.

NewPing sonar(TRIGGER_PIN, ECHO_PIN, MAX_DISTANCE); // NewPing setup of pins and maximum distance.

Statistic myStats; 

void setup() {
  Serial.begin(115200); 
  myStats.clear();
}

void loop() {
  delay(50);                     
  myStats.add(sonar.ping());
  if (myStats.count() == 500)
        {
        Serial.print("  Average: ");
        Serial.print(myStats.average(), 2);
        Serial.print("  Std deviation: ");
        Serial.print(myStats.pop_stdev(), 2);
        Serial.println();
        }
}

------------------------------------------------

I dati, di una prova sicuramente parziale ma comunque indicativa della fattibilita', e' riportata nella figura successiva

Attenzione: si parla di tempi di andata e ritorno dell'impulso.

Molto indicativamente si ha che un centimetro di distanza corrisponde, nelle condizioni di misura, a circa 60 ms quindi se si vuole cerca di misurare una variazione di 1mm si deve riuscire a separare almeno 6 ms. Considerando che l'errore medio di deviazione standard e' di circa 3 ms usare l'SR-04 per misurare con la precisione del millimetro e' decisamente al limite delle proprie possibilita' (si comincia a ragionare se la risoluzione e' un decimo della grandezza che si vuole misurare)

secondo i dati teorici con  temperatura di 20°C la velocita' del suono in aria e' di 0.0343 cm/ms (343 m/s) il tempo di volo e' di 6 ms per mm (andata e ritorno 2 mm) il che ritorna abbastanza bene con quanto misurato