Raspberry Pi e Particle Cloud: un connubio perfetto!

Particle Cloud è il modo più semplice e veloce per ottenere soluzioni IoT. La piattaforma cloud e l'hardware di connettività sono perfetti sia per il primo prototipo sia per le applicazioni di produzione. Il collegamento della Raspberry Pi al Particle Cloud fornisce alcune caratteristiche interessanti per la costruzione di molti progetti.

Introduzione

Il Raspberry Pi è un single-board computer a basso costo, forse il più popolare al mondo. E' un potente strumento di sviluppo per la creazione di progetti IoT. Il collegamento della scheda Pi al Particle Cloud permette la semplice progettazione di soluzioni IoT. L'iscrizione abilita l'utente al download del pacchetto software gratuito per collegare il Raspberry Pi al Cloud. L'installazione è veloce e intuitiva per svariate applicazioni. Attraverso l'IDE Particle Web sarà possibile simulare codice Arduino per la programmazione della scheda Raspberry Pi.  Con Particle per Raspberry Pi è possibile programmare in C / C ++ per eseguire semplici operazioni come il lampeggio di un LED o la lettura di sensori. E' possibile salvare in modo sicuro tutti gli aggiornamenti e riprogrammare le varie schede Pi presenti all'interno dell'IDE Web. Altre proprietà sono:

  • Batch Script Execution: eseguire in remoto script personalizzati su gruppi di Raspberry Pi.
  • Remote Data Collection: raccogliere e pubblicare dati su Particle Cloud.
  • Integrazioni: funzionalità avanzate con IFTTT, Google Cloud, Microsoft Azure.

Un progetto IoT con la camera Pi

La sicurezza è fondamentale nella vita quotidiana e lavorativa, e disporre di una camera per catturare immagini di intrusi in una determinata stanza può essere di notevole aiuto nella messa in sicurezza di vari oggetti. Questo progetto comprende un sensore di movimento PIR, una camera fotografica, e un modulo LED che si illumina per catturare immagini di intrusi in maniera automatica, pubblicando successivamente tutte le foto sul web.

La  fotocamera raspberry Pi è un sensore di immagine Sony IMX219 di alta qualità da 8 megapixel progettata su misura per Raspberry Pi, con un obiettivo a fuoco fisso. E' in grado di catturare immagini statiche da 3280 x 2464 pixel, con supporto anche di video con una risoluzione massima di 1920 x 1080 x 10bpp a 30 fps. La scheda Pi controlla il sensore PIR per rilevare il movimento all'interno del suo campo di vista. Se viene rilevato qualcosa, gli anelli di LED del modulo vengono attivati e illuminano la scena, in modo da poter catturare gli intrusi sia in ambienti luminosi che bui. La fotocamera scatta una foto e utilizza la connessione del Pi a Internet per caricare il file nella cartella personale Dropbox. Per collegare il Raspberry Pi al Particle Cloud, è necessario installare Particle Agent: un servizio software che viene eseguito in background sul Raspberry Pi e permette di scrivere ed eseguire il firmware (il software che interagisce con i pin GPIO della scheda Pi).

Dopo aver predisposto il Raspberry Pi per il funzionamento e collegato al web, è sufficiente copiare e incollare il seguente comando per scaricare e installare il software Particle Pi:

bash <( curl -s https://raw.githubusercontent.com/spark/particle-agent/master/bin/cloud-install )

Il Raspberry Pi dovrebbe scaricare automaticamente i tool necessari e installare il pacchetto software Particle Agent. Seguendo le istruzioni sullo schermo si dovrebbe accedere al proprio account Particle e fornire all'hardware Pi un nome di identificazione. Una volta che il Pi è stato identificato, si dovrebbe essere in grado di vederlo nella lista dei dispositivi nell'IDE Web. Prima di poter iniziare a scattare foto, è necessario collegare la fotocamera alla scheda Raspberry Pi tramite il connettore della fotocamera e attivarlo via Raspi-config. Il modo più semplice per verificare che la fotocamera sia configurata correttamente è quello di cercare di acquisire un'immagine. È possibile utilizzare il seguente comando raspistill per confermare la configurazione della telecamera:

raspistill -vf -hf -o /home/pi/picam/prova.jpg

Successivamente, bisogna scaricare e configurare uno script sulla scheda Raspberry Pi per fornire i privilegi di accesso alla cartella Dropbox. Il prossimo passo è quello di cablare l'hardware, e utilizzare semplici esempi di codice sul Raspberry Pi per verificare che tutto funzioni correttamente (Figura 1 e 2). I due componenti principali che dobbiamo validare sono il sensore PIR e il LED NeoPixel. Utilizzare il seguente codice per testare l'anello LED, copiandolo e incollandolo nell'IDE Web e facendo clic sull'icona a stella accanto al dispositivo nel pannello "Devices".

#include "Particle.h"
#include "ws2811.h"

#define TARGET_FREQ  WS2811_TARGET_FREQ
#define GPIO_PIN     18
#define DMA          5
#define STRIP_TYPE   SK6812_STRIP_RGBW    // SK6812RGBW (NOT SK6812RGB)
#define LED_COUNT    16

ws2811_t ledstring = {
    NULL,
    NULL,
    TARGET_FREQ,
    DMA,
    {
        {
            GPIO_PIN,
            0,
            LED_COUNT,
            STRIP_TYPE,
            NULL,
            255,
            0,
            0,
            0,
            0,
        },
        {
            0,
            0,
            0,
            0,
            NULL,
            0,
            0,
            0,
            0,
            0,
        },
    },
};


void rainbow(uint8_t wait);
uint32_t Wheel(byte WheelPos);

void setup()
{
  ws2811_init(&ledstring);
}

void loop() {
  rainbow(20);
}

uint8_t brightness = 32;
uint32_t color(uint8_t r, uint8_t g, uint8_t b, uint8_t w = 0) {
  return
    ((((uint32_t)w * brightness) >> 8) << 24) | ((((uint32_t)r * brightness) >> 8) << 16) | ((((uint32_t)g * brightness) >> 8) << 8) | ((((uint32_t)b * brightness) >> 8));
}

void rainbow(uint8_t wait) {
  uint16_t i, j;

  for(j=0; j<256; j++) {
    for(i=0; i<LED_COUNT; i++) {
      ledstring.channel[0].leds[i] = Wheel((i+j) & 255);
    }
    ws2811_render(&ledstring);
    delay(wait);
  }
}

// Input a value 0 to 255 to get a color value.
// The colours are a transition r - g - b - back to r.
uint32_t Wheel(byte WheelPos) {
  if(WheelPos < 85) {
   return color(WheelPos * 3, 255 - WheelPos * 3, 0);
  } else if(WheelPos < 170) {
   WheelPos -= 85;
   return color(255 - WheelPos * 3, 0, WheelPos * 3);
  } else {
   WheelPos -= 170;
   return color(0, WheelPos * 3, 255 - WheelPos * 3);
  }
}

Figura 1: il test dell'anello LED

Il sensore PIR richiede 5V, la sua uscita è 3.3V in modo che possa essere collegato direttamente ad un ingresso GPIO. Il codice di test è il seguente:

#include "Particle.h"
#include "ws2811.h"
#include "stdarg.h"

#define TARGET_FREQ  WS2811_TARGET_FREQ
#define GPIO_PIN     18
#define DMA          5
#define STRIP_TYPE   SK6812_STRIP_RGBW    // SK6812RGBW (NOT SK6812RGB)
#define LED_COUNT    16

ws2811_t ledstring = {
    NULL,
    NULL,
    TARGET_FREQ,
    DMA,
    {
        {
            GPIO_PIN,
            0,
            LED_COUNT,
            STRIP_TYPE,
            NULL,
            255,
            0,
            0,
            0,
            0,
        },
        {
            0,
            0,
            0,
            0,
            NULL,
            0,
            0,
            0,
            0,
            0,
        },
    },
};

uint32_t color(uint8_t r, uint8_t g, uint8_t b, uint8_t w);


bool pirState = LOW;

void setup()
{
  ws2811_init(&ledstring);
  pinMode(26,INPUT_PULLDOWN);
  for(uint8_t i=0; i<LED_COUNT; i++) {
      ledstring.channel[0].leds[i] = color(0,100,0,0);
    }
    ws2811_render(&ledstring);
    delay(500);
}


void loop()
{
    //This will run in a loop

    int value = digitalRead(26);

    if (value == HIGH) {    // check if the input is HIGH
      ////Turn on all the neopixles
      if (pirState == LOW) {
            // we have just turned on
            pirState = HIGH;
            for(uint8_t i=0; i<LED_COUNT; i++) {
              ledstring.channel[0].leds[i] = color(250,250,250,250);
            }
            ws2811_render(&ledstring);
            delay(20);
          }
    } else {
      //Turn off all the neopixles
      for(uint8_t i=0; i<LED_COUNT; i++) { ledstring.channel[0].leds[i] = color(0,0,0,0); } ws2811_render(&ledstring); delay(20); if (pirState == HIGH) pirState = LOW; } } uint8_t brightness = 32; uint32_t color(uint8_t r, uint8_t g, uint8_t b, uint8_t w = 0) { return ((((uint32_t)w * brightness) >> 8) << 24) | ((((uint32_t)r * brightness) >> 8) << 16) | ((((uint32_t)g * brightness) >> 8) << 8) | ((((uint32_t)b * brightness) >> 8));
}

Figura 2: il test del sensore PIR

Una volta testato l'hardware, si collega il tutto (Figura 3 e 4) e si configura correttamente la scheda attraverso il firmware scaricandolo dal seguente link.

Figura 3: schema del progetto

 

Figura 4: il progetto assemblato

 

Conclusioni

La maggior parte dei progetti Raspberry Pi ha l'obiettivo di connettere vari dispositivi e controllarli da remoto. Particle è un servizio Web che contribuisce a rendere questo processo un po' più facile con un programma beta che si aggiunge nel Raspberry Pi.  Particle è essenzialmente un cloud server che memorizza i dati e gli script che consentono di controllare un Raspberry Pi da remoto. Questo essenzialmente elimina la necessità di avviare un server per una serie di progetti. Una volta che si effettua l'iscrizione per la versione beta, si avrà accesso ad una serie di librerie per facilitare la programmazione. La casa madre Particle dispone anche di schede di sviluppo come Photon ed Electron che analizzeremo in una prossima review.

 

 

 

Una risposta

  1. Maurizio Di Paolo Emilio Maurizio Di Paolo Emilio 21 aprile 2017

Scrivi un commento

ESPertino è la nuova scheda per IoT compatibile ARDUINO.
Scopri come averla GRATIS!