Kursy • Poradniki • Inspirujące DIY • Forum

3 podstawowe rodzaje akumulatorów, które warto znać

Co ciekawego w DIY? 10 projektów naszych czytelników #33

Piezoelektryki – czym są materiały piezoelektryczne?

Jak czytać oznaczenia baterii? Norma IEC 60086-1 w praktyce

Jak działa płyta indukcyjna? Czym są prądy wirowe?

Zbuduj robota

z Arduino

Diody świecące

Jaki rezystor?

Kursy Artykuły

DIY Forum

Particle w praktyce – budowa prostych urządzeń IoT

Pozostałe Mateusz Lerczak

Particle to ekosystem, który ma ułatwiać budowę urządzeń IoT. Od sprzętu, przez łączność, aż do odpowiedniego oprogramowania.

Oto przykład wykorzystania urządzeń z rodziny Particle do budowy prostych, bezprzewodowych sensorów, które monitorują m.in. wilgotność.

Artykuł przesłany przez czytelnika:

Pora na opisanie moich eksperymentów ze sprzętem z rodziny Particle, konkretnie mowa o module Mesh WiFi Bundle oraz Relay Shield. Zacznę od krótkiego wprowadzenia skąd pomysł na wykorzystanie tej rodziny modułów, następnie opiszę jak miało być oraz co finalnie udało się uzyskać.

Chciałem przetestować mój pomysł na stworzenie systemu, który będzie monitorował zużycie mediów w domu/biurze. Pierwotnie zestaw miał składać się z 3 czujników iNode Energy Meter i wspomnianego wcześniej Mesh WiFi Bundla.

Niestety przed zakupem nie wiedziałem, że moduły Particla obecnie nie umożliwiają komunikacji przez Bluetooth z innymi urządzeniami. W tej chwili BT jest używany tylko przy konfiguracji tego sprzętu. Tak więc nie ma mowy o odczycie danych z iNode-ów. Dodatkowym problemem byłby format danych wysyłanych przez iNody. Finalnie, moja sieć typu Mesh została więc prostym agregatorem informacji o temperaturze i wilgotności.

Particle w praktyce - pierwszy test

W zestawie od Particla otrzymujemy 3 minikomputery (jednego Argona oraz 2 szt. Xenona). Argon pełni najważniejszą rolę, ponieważ właśnie dzięki niemu mamy połączenie z internetem (poprzez WiFi). Xenon jest elementem końcowym, do którego dołączyłem cyfrowy termometr DHT11.

Bez Argona, Xenony nie połączą się z internetem, więc z IoT zostaje nam samo T.

Układ testowy z czujnikiem DHT11

Na powyższym zdjęciu widać płytkę prototypową z czujnikiem DHT11. Zestaw został podsunięty pod wylot powietrza laptopa, aby w szybkim tempie możliwe było zebranie zróżnicowanych danych.

Układ pomiarowy w oparciu o Particle

Podczas wykonywania testów mierzyłem temperaturę i wilgotność w 3 miejscach:

salon - czujnik przysunięty do laptopa,
łazienka - czujnik powieszony na ścianie,
samochód - czujnik pozostawiony na całą noc w aucie, zasilany przez power bank.

Oprogramowanie

Przesyłanie danych do chmury jest stosunkowo proste. W pierwszej kolejności w naszym programie, pisany w Arduino, musimy wywołać następujące polecenie:

Particle.publish("humidity", String::format("%.2f", humidity), PRIVATE);

Dzięki temu w konsoli chmury Particle zobaczymy dane, które będą podobne do poniższych:

Przykładowe dane widoczne w konsoli

Jeżeli chcemy wysłać dane do innej chmury (np. ThingSpeaka) to musimy najpierw utworzyć stosowny mechanizm integracji. W panelu Particle'a dostępna jest odpowiednia opcja, a opis jej wykorzystania znaleźć można np. w tym poradniku.

Opcja do tworzenia integracji

Wracając jednak do meritum, ostateczny kod napisany w Arduino, który wysyła dane z czujnika do chmury prezentował się następująco:

#include "Adafruit_DHT.h"

// Example testing sketch for various DHT humidity/temperature sensors
// Written by ladyada, public domain

#define DHTPIN 2     // what pin we're connected to

// Uncomment whatever type you're using!
#define DHTTYPE DHT11		// DHT 11 
//#define DHTTYPE DHT22		// DHT 22 (AM2302)
//#define DHTTYPE DHT21		// DHT 21 (AM2301)

// Connect pin 1 (on the left) of the sensor to +5V
// Connect pin 2 of the sensor to whatever your DHTPIN is
// Connect pin 4 (on the right) of the sensor to GROUND
// Connect a 10K resistor from pin 2 (data) to pin 1 (power) of the sensor

double humidity = 0;
double temperature = 0;


DHT dht(DHTPIN, DHTTYPE);

void setup() {
    dht.begin();
	
    Particle.variable("humidity", &humidity, DOUBLE);
    Particle.variable("temperature", &temperature, DOUBLE);
	
    Particle.function("gHumidity", h);
    Particle.function("gTemperature", t);
}

void loop() {
    humidity = dht.getHumidity();
    temperature = dht.getTempCelcius();
	
    if (isnan(humidity) || isnan(temperature)) {
        Particle.publish("error", "Measurement error", PRIVATE);
        return;
    } else {
        if (temperature > 100) {
            return;
        }
        
        Particle.publish("humidity", String::format("%.2f", humidity), PRIVATE);
        Particle.publish("HE7-Humidity",  String::format("%.2f", humidity), PRIVATE);

        delay(30000);

        Particle.publish("temperature", String::format("%.2f",temperature), PRIVATE);
        Particle.publish("HE7-Temperature",  String::format("%.2f", temperature), PRIVATE);

        delay(300000);
    }
}

double h(String command)
{
    delay(2000);
    humidity = dht.getHumidity();
	
    Particle.publish("humidity", String::format("%.2f", humidity), PRIVATE);
    Particle.publish("HE7-Humidity",  String::format("%.2f", humidity), PRIVATE);
    
    return humidity;
}

double t(String command)
{
    delay(2000);
    temperature = dht.getTempCelcius();
	
    Particle.publish("temperature", String::format("%.2f",temperature), PRIVATE);
    Particle.publish("HE7-Temperature",  String::format("%.2f", temperature), PRIVATE);
    
    return temperature;
}

Poniżej widoczne są przykładowe wykresy pomiaru wilgotności oraz temperatury. Nagły skok podczas jednego z pomiarów był prawdopodobnie spowodowany błędnym odczytem z czujnika DHT11.

: Pomiar wilgotności

: Pomiar temperatury

Test modułu Relay Shield

Następnie zabrałem się za testy RelayShielda, czyli modułu wyposażonego w 4 przekaźniki. Pierwszy problem, który napotkałem to brak współpracy z Argonem/Xenonem. Płytki te są nowsze i nie pasują do modułu z przekaźnikami. Jedynym sposobem na spięcie tego sprzętu było więc ręczne wykonanie połączenia przewodowego.

Przewodowe połączenie między modułami

Wadą tego modułu jest konieczność wykorzystania zewnętrznego zasilacza 7-20V DC. Niestety nie da się go zasilać np. bezpośrednio z 230V AC, co byłoby tutaj dużą zaletą. Przy docelowym projekcie konieczne jest więc zastosowanie dodatkowego zasilacza.

Podczas pierwszych testów nie podłączałem do modułu żadnego obciążenia, które korzystałoby z napięcia sieciowego. Napisałem za to prosty kod, który losował liczbę z zakresu od 1 do 4 i włączał dany port. Kod programu testowego wyglądał następująco:

int RELAY1 = D3;
int RELAY2 = D4;
int RELAY3 = D5;
int RELAY4 = D6;
int PREV_RELAY = 0;
bool DISCO = false;
int DISCO_DELAY = 500;

int randomMinMax(int minRand, int maxRand)
{
    return rand() % (maxRand-minRand+1) + minRand;
}

void setup()
{
   //Initilize the relay control pins as output
   pinMode(RELAY1, OUTPUT);
   pinMode(RELAY2, OUTPUT);
   pinMode(RELAY3, OUTPUT);
   pinMode(RELAY4, OUTPUT);
   // Initialize all relays to an OFF state
   digitalWrite(RELAY1, LOW);
   digitalWrite(RELAY2, LOW);
   digitalWrite(RELAY3, LOW);
   digitalWrite(RELAY4, LOW);

   //register the Particle function
   Particle.function("relayOn", relayOn);
   Particle.function("relayOff", relayOff);
   Particle.function("relayDisco", relayDisco);
   Particle.function("stopDisco", stopDisco);
   Particle.function("startDisco", startDisco);
   Particle.variable("DISCO_DELAY", &DISCO_DELAY, INT);
}

void loop()
{
    if (true == DISCO) {
        delay(DISCO_DELAY);
        relayDisco("");
    }
}


int relayOn(String command)
{
    int relayNumber = command.toInt();
    
    Particle.publish("relay_on", String::format("%d", relayNumber), PRIVATE);
    
    if (relayNumber < 1 || relayNumber > 4) return -1;

    digitalWrite(relayNumber+2, 1);
    return 1;
}

int relayOff(String command)
{
    int relayNumber = command.toInt();
    
    Particle.publish("relay_off", String::format("%d", relayNumber), PRIVATE);
    
    if (relayNumber < 1 || relayNumber > 4) return -1;

    digitalWrite(relayNumber+2, 0);
    return 1;
}

int relayDisco(String command)
{
    int randomRelay = randomMinMax(3,6);
    int randomDelay = randomMinMax(1000, 2000);
    
    if (randomRelay == PREV_RELAY) {
        Particle.publish("disco", "Same as last relay, re-run..", PRIVATE);
        relayDisco("");
    }
    
    Particle.publish("disco", String::format("Relay %d with %d ms delay", randomRelay-2, randomDelay), PRIVATE);
    
    digitalWrite(randomRelay, 1);
        
    delay(randomDelay);
        
    digitalWrite(randomRelay, 0);
    
    PREV_RELAY = randomRelay;
    
    return 1;
}

int stopDisco(String command)
{
    Particle.publish("disco", "Disco has been stopped", PRIVATE);
    DISCO = false;
    return 1;
}

int startDisco(String command)
{
    Particle.publish("disco", "Disco has been started", PRIVATE);
    DISCO = true;
    return 1;
}

Działanie programu widoczne jest na poniższym, krótkim nagraniu:

Podsumowanie

Sprzęt firmy Particle jest ciekawym zestawem do budowy prototypów urządzeń IoT. Dużą zaletą tego ekosystemu jest obszerna dokumentacja i chmura producenta, która znacznie ułatwia pierwsze kroki w świecie internetu rzeczy. Moduły pobierają stosunkowo mało prądu, ale mimo to charakteryzują się dobrym zasięgiem (brak problemów z komunikacją przez ścianę). Do wad tego systemu należy zaliczyć wysoką cenę (zestaw startowy to 459 zł). Co więcej, moduły pracują w standardzie 3,3V, co może być problemem dla początkujących elektroników. Macie jakieś swoje doświadczenia z Particle?

Czy wpis był pomocny? Oceń go:

Średnia ocena 4.7 / 5. Głosów łącznie: 15

Nikt jeszcze nie głosował, bądź pierwszy!

Autor: Mateusz Lerczak

Artykuł był ciekawy?

Dołącz do 20 tysięcy osób, które otrzymują powiadomienia o nowych artykułach! Zapisz się, a otrzymasz PDF-y ze ściągami (m.in. na temat mocy, tranzystorów, diod i schematów) oraz listę inspirujących DIY na bazie Arduino i Raspberry Pi.