Zaloguj
Fale tsunami rozchodzą się pierścieniowo od miejsca wzbudzenia. Na pełnym morzu poruszają się z wielką prędkością (do 900 km/h), przez co łatwo je przeoczyć, ponieważ ich długość dochodzi do kilkuset kilometrów, ale wysokość nie przekracza kilkudziesięciu centymetrów. Dopiero w strefie brzegowej fala ulega spiętrzeniu i może osiągnąć wysokość kilkudziesięciu metrów, niszcząc nadbrzeżne miejscowości. Najczęściej występują w basenie Oceanu Spokojnego.
Na początku lata tego roku ogłoszono, że obszar na Alasce zwany Prince William Sound, zostanie nieoczekiwanie dotknięty tsunami, zainicjowanym przez globalne ocieplenie. Naukowcy, którzy dokonali odkrycia, wskazali na obszar szybko cofającego się lodu. Pozostawił po sobie górę ułomków skalnych, które zsunęły się do fiordu i zainicjowały falę o wysokości 10 metrów, która ostatecznie uderzyła w miasto Whittier. Nie jest to pierwsze tsunami nawiedzające Alaskę. Obecnie region jest stale monitorowany przez podwodne sensory, wykrywające anomalie i duże fale, zbliżające się do brzegu.
WetRuler (Mokra Linijka) to układ przeznaczony do zdalnego monitorowania poziomu wody. Wygląd takiego systemu pokazuje fotografia 1.
Jest w stanie mierzyć poziom oceanu i wysyłać dane do odbiornika, poprzez sieć LoRa lub bezpośrednio przez GSM. Jednostki są kompaktowe i odporne na warunki środowiskowe. Są wyposażone w baterie i zasilane energią słoneczną. System stworzono z myślą o zastosowaniu, jako narzędzie wczesnego ostrzegania przed wystąpieniem tsunami. Jednakże autor miał okazję przetestować go tylko jako monitor wysokości pływów morskich.
Potrzebne komponenty
Autor skonstruował dwie wersje urządzenia – jedna obejmuje wysyłanie danych poprzez GSM (sieć komórkową), a druga przez LoRa. We własnej konstrukcji można rozważyć również połączenie z radiolatarnią satelitarną, ponieważ wiele obszarów nadbrzeżnych nie ma zasięgu telefonii komórkowej. Sensorem jest MS580314BA, czyli specjalistyczny czujnik ciśnienia firmy TE Connectivity. Często stosuje się go w systemach monitorowania danych w środowisku morskim. Więcej informacji na jego temat i różnych jego aplikacji, znaleźć można tu [1], [2].
Do budowy systemu potrzebne będą:
- Sensor ciśnienia MS580314BA. Można kupić sam czujnik za około 13 dolarów lub przylutowany na płytce, w formie modułu SparkFun, za ok. 60 dolarów. Wystarczy dobra lutownica i odpowiednia płyta uniwersalna, aby samodzielnie sobie z tym poradzić;
- Moduły LoRa – autor zastosował TTGO LORA32 firmy LILYGO. Są to moduły radiowe, pracujące przy częstotliwości 868 lub 915 MHz, zintegrowane z SoC ESP32. Moduł taki kosztuje około 27 dolarów;
- Płytka Arduino MKR GSM 1400 – to świetna płytka Arduino z komunikacją GSM, kosztuje ok. 55 dolarów;
- Ogniwa słoneczne Uxcell, 2 szt. na urządzenie. Ogniwo takie daje napięcie 6 V przy prądzie do około 180 mA, ma wymiary 133×73 mm i kosztują ok. 8 dolarów;
- Akumulator 18650;
- Ładowarka na układzie TP4056;
- Włącznik zewnętrzny, wodoodporny. Autor użył w tym celu przycisk w wykonaniu wandaloodpornym z wbudowanym podświetleniem LED;
- Tester poziomu naładowania akumulatora – Icstation 1S z niebieskim wyświetlaczem LED;
- Scalony timer Adafruit TPL5111 – prosty, mały układ do pomiaru czasu, zamontowany na płytce drukowanej;
- Tranzystor MOSFET z kanałem typu N – autor wybrał element o napięciu maksymalnym 30 V i prądzie drenu do 60 A;
- Różnicowy przedłużacz I2C typu PCA9600, pozwalający na wydłużenie odległości pomiędzy sensorem a mikrokontrolerem. Potrzebne są dwa takie moduły. Autor umieścił sensor w odległości około 8 metrów od mikrokontrolera. Do połączenia użyto zwykłego kabla o czterech parach przewodów przeznaczonego do użytku zewnętrznego;
- Moduł Adafruit BMP388 do precyzyjnego pomiaru ciśnienia barometrycznego i szacowania wysokości nad poziomem morza.
Budowa sensora
Czujniki MS580314BA należy przylutować do małych płytek drukowanych, jak pokazano na fotografii 2.
Dwie wcześniejsze prace (patrz linki we wcześniejszej części artykułu) dają kilka wskazówek jak to zrobić. Podczas lutowania dobrze jest skorzystać z niskotemperaturowego lutowia, by nie przegrzać sensora, a na koniec sprawdzić multimetrem poprawność montażu i wyeliminować ewentualne zwarcia. Pozostała część okablowania sensora jest łatwa do wykonania. Należy rozpocząć od umieszczenia małego kondensatora (0,1 nF), między przewodami zasilania i masy. Następnie należy podciągnąć linie CS i PSB, aby zainicjować I2C i ustalić adres czujnika (fotografia 3).
Istnieją dwie możliwości adresowania, zależne od stanu wyprowadzenia konfigurującego: adres 0x76 odpowiada stanowi wysokiemu, natomiast 0x77, niskiemu. Autor w swojej konstrukcji użył obydwu, aby zbudować „różdżkę” z dwoma czujnikami, rozstawionymi o jedną stopę (ok. 30 cm), i uzyskać różnicę ciśnień w pomiarze.
Dla czujnika została zaprojektowana i wykonana na drukarce 3D obudowa, która umożliwia jego całkowite zamknięcie (zalanie) w przezroczystej żywicy epoksydowej (fotografia 4).
Otwór w obudowie idealnie pasuje do malutkiej, nierdzewnej szyjki czujnika. Połączenie to należy uszczelnić, np. za pomocą Superglue, który będzie nie tylko zamykał obudowę, ale utrzymywał na miejscu sensor. Projekt obudowy dla MS580314BA można znaleźć na stronie projektu, na witrynie instructables.com, w postaci pliku STL.
Obudowa
Obudowy modułów z GSM i LoRa są takie same. Obie wykonano w technologii druku 3D, z bocznymi wstawkami dla paneli słonecznych. Jedyną modyfikacją dla modułu z interfejsem LoRa było dodanie otworu na antenę, który należy wywiercić tak, aby pasował do posiadanej przez nas anteny. Antena GSM w całości mieści się w obudowie, więc nie ma potrzeby wykonywania dodatkowych otworów.
Środek obu modułów jest identyczny, z otworami na włącznik i przyciskiem do włączania ekranu, pokazującego poziom baterii. Stopki obudowy są drukowane oddzielnie i przyklejane do skrzynek w rogach, aby zapewnić możliwość montażu urządzenia w terenie. Mała wieżyczka z gwintem i pasująca pokrywka, są przyklejone wokół otworu na port microUSB, aby chronić go przed wnikaniem wody. Urządzenie jest w zasadzie wodoodporne. Do wydruków należy użyć tworzywa PETG, aby zminimalizować odkształcenia cieplne.
Elementy wewnętrzne umieszczone są za pomocą mosiężnych mocowań z gwintem M3, wtapianych w obudowę. W plikach do pobrania można znaleźć dwa mocowania czujników, ponieważ w systemie są dwa czujniki, rozstawione na głowicy pomiarowej, którą wykonano ze szkła akrylowego. Oprócz dwóch sensorów, na głowicy znajduje się również szczelna puszka, w której zamknięty jest konwerter interfejsu I2C na sygnał różnicowy, co pozwala przesłać go na większą odległość. Puszka z konwerterem, także zalana jest żywicą epoksydową, w celu zapewnienia szczelności.
Odbiornik LoRa korzysta z gotowej obudowy, wyposażonej w okienko na wyświetlacz OLED. Obudowę tę można znaleźć tu [3]. Wszystkie komponenty systemu przygotowane do połączenia pokazuje fotografia 5.
Połączenia elektryczne
Czujniki ciśnienia są połączone równolegle z liniami SDA, SCL oraz liniami zasilania, w pojedynczym kablu, wykorzystującym skręcone pary. Po drodze, przy samych sensorach, dołączone są wzmacniacze I2C. Są one bardzo łatwe w instalacji – wystarczy podłączenie obu czujników do linii wejściowych i pośredni długi kabel (o długości do 60 metrów), który podłączony jest do drugiego wzmacniacza – odbiornika. Jeśli potrzebne jest wydłużenie połączenia, konieczna może być zmiana rezystorów, podciągających linie SDA i SCL na płytach. Schematy połączenia poszczególnych modułów i elementów pokazano na rysunku 1.
System działa na bardzo prostej zasadzie – włącznik doprowadza zasilanie do modułu czasowego Adafruit TPL5111, który ustawia wysoki poziom na wyprowadzeniu Enable co 10 minut (można oczywiście ustawić mniejszą lub większą częstotliwość transmisji danych). Moduł ksteruje tranzystorem MOSFET zasilającym główny moduł LoRa lub Arduino 400 GSM. Tranzystor to konieczność, ponieważ moduł TPL5111 nie jest w stanie dostarczyć dostatecznie dużego prądu do działania modułu GSM.
Zasilanie czujników i BMP388 pochodzi z płytki głównej, gdy jest ona włączona. Rezystory podciągające są we wzmacniaczach I2C i nie ma konieczności dodawania ich do interfejsu. Moduł ładowarki TP4056 działa świetnie z dwoma panelami słonecznymi i dołączoną baterią 18650 lub podobną. Przycisk łączy wyjście baterii z małym ekranem poziomu baterii. Dwa czujniki dołączone do zanurzonego sensora, wykorzystują dwa dostępne adresy, w tym adres układu BMP388 (0x77), więc jeśli wykorzystuje się dwa czujniki, to układ BMP388 musi być podłączony do układu poprzez SPI.
Oprogramowanie
Oprogramowanie systemu jest naprawdę proste. Bazuje na bibliotekach przewidzianych dla czujników, które działają doskonale bez żadnej ingerencji, oraz na bibliotekach GSM Blynk dla Arduino, które doskonale współpracują z chmurą Hologram (usługa może być niedostępna w Polsce). Wystarczy zarejestrować się, aby założyć konto Hologram i otrzymać kartę SIM, którą należy następnie umieścić w płytce Arduino 400 GSM. Cały proces logowania do sieci i chmury, jest obsługiwany przez bibliotekę GSM Blynk dla Arduino. Szkic Arduino IDE zastosowany do kontroli systemu, z wykorzystaniem GSM, umieszczono na listingu 1.
#define BLYNK_PRINT Serial
#include <SPI.h>
#include <MKRGSM.h>
#include <BlynkSimpleMKRGSM.h>
#include <Wire.h>
#include <Adafruit_Sensor.h>
#include "Adafruit_BMP3XX.h"
#define BMP_SCK 9
#define BMP_MISO 8
#define BMP_MOSI 7
#define BMP_CS 6
#include <SparkFun_MS5803_I2C.h> // Biblioteka do pobrania tutaj: http://librarymanager/All#SparkFun_MS5803-14BA
MS5803 sensor(ADDRESS_HIGH);
MS5803 sensor2(ADDRESS_LOW);
Adafruit_BMP3XX bmp(BMP_CS, BMP_MOSI, BMP_MISO, BMP_SCK);
// Utwórz zmienną do przetrzymywania wyników pomiaru
float temperature_c, temperature_f, temperature2_f;
double pressure_abs, pressure_abs2, pressure_relative, altitude_delta, pressure_baseline, pressure_baseline2;
#define DONEPIN 4
int pressureOne;
int pressureTwo;
int pressureThree;
int waterFeet;
int counter = 0;
GSMClient client;
GPRS gprs;
GSM gsmAccess;
BlynkTimer timer;
// Uyskanie tokena uwierzytelniania w Blynk App.
// Konfigurowanie w ustawieniach projektu Blynk.
char auth[] = "";
// Dane do logowania do karty SIM i sieci GPRS
// Należy pozostawić puste, jeśli pin, hasło etc są nieużywane
char pin[] = "";
char apn[] = "hologram";
char user[] = "";
char pass[] = "";
void endGame()
{
delay(5000);
Serial.print("got here");
while (1) {
digitalWrite(DONEPIN, HIGH);
delay(1);
digitalWrite(DONEPIN, LOW);
delay(1);
}
}
void myTimerEvent()
{
// Możliwe jest wysłanie dowolnej wartości w dowolnym czasie
// ale nie rekomenduje się wysyłania więcej niż 10 na sek.
Blynk.virtualWrite(V5, pressureOne);
Blynk.virtualWrite(V6, pressureTwo);
Blynk.virtualWrite(V4, pressureThree);
waterFeet = ( pressureOne - pressureThree ) * (pressureOne - pressureTwo);
Blynk.virtualWrite(V3, waterFeet);
counter = counter + 1;
if (counter = 2){
endGame();
}
}
void setup()
{
// Konsola do debugowania
Serial.begin(9600);
delay(1500);
Wire.begin();
pinMode(DONEPIN, OUTPUT);
pinMode(DONEPIN, LOW);
if (!bmp.begin()) {
Serial.println("Could not find a valid BMP3 sensor, check wiring!");
while (1);
}
delay(1000);
sensor.reset();
sensor.begin();
sensor2.reset();
sensor2.begin();
bmp.setTemperatureOversampling(BMP3_OVERSAMPLING_8X);
bmp.setPressureOversampling(BMP3_OVERSAMPLING_4X);
bmp.setIIRFilterCoeff(BMP3_IIR_FILTER_COEFF_3);
Blynk.begin(auth, gsmAccess, gprs, client, pin, apn, user, pass);
timer.setInterval(2000L, myTimerEvent);
}
void loop()
{
Blynk.run();
timer.run(); // Inicjalizacja BlynkTimer
if (! bmp.performReading()) {
Serial.println("Failed to perform reading :(");
return;
}
delay(2000);
bmp.performReading();
Serial.print("Temperature = ");
Serial.print(bmp.temperature);
Serial.println(" *C");
pressureThree = bmp.pressure / 100;
Serial.print("Pressure = ");
Serial.print(bmp.pressure / 100.0);
Serial.println(" hPa");
// Odczytaj temperaturę z sensora w Fahrenheitach, skonwertuj ją.
temperature_f = sensor.getTemperature(FAHRENHEIT, ADC_512);
temperature2_f = sensor2.getTemperature(FAHRENHEIT, ADC_512);
// Odczytaj ciśnienienie z sesora (w mbar)
pressureOne = sensor.getPressure(ADC_4096);
pressureTwo = sensor2.getPressure(ADC_4096);
// Wysłanie danych poprzez UART
Serial.print("Temperature2 F = ");
Serial.println(temperature2_f);
Serial.print("Temperature F = ");
Serial.println(temperature_f);
Serial.print("Pressure abs (mbar)= ");
Serial.println(pressureOne);
Serial.print("Pressure abs 2(mbar)= ");
Serial.println(pressureTwo);
delay(2000);
}
Adafruit udostępnia bibliotekę dla sensorów BMP, a do obsługi sensora MS5803, autor użył biblioteki udostępnionej przez SparkFun.
Do sterowania częstotliwością przesyłania danych zastosowano timer Blynk, aby zminimalizować ilość przesyłanych danych i nie narażać się na wysokie koszty przesyłu danych przez GSM. Autor przesyłał około 3 MB tygodniowo, co kosztowało go ok. 40 centów za ten okres.
#include <LoRa.h>
#include <Wire.h>
#define DONEPIN 13
// Definicja pinów, używanych przez transceiver LoRa
#define SCK 5
#define MISO 19
#define MOSI 27
#define SS 18
#define RST 14
#define DIO0 26
// 433E6 dla Azji
// 866E6 dla Europy
// 915E6 dla północnej Ameryki
#define BAND 866E6
// Piny ekranu OLED
#define OLED_SDA 4
#define OLED_SCL 15
#define OLED_RST 16
#define SCREEN_WIDTH 128 // szerokość ekranu OLED w pikselach
#define SCREEN_HEIGHT 64 // wysokość ekranu OLED w pikselach
#include <SparkFun_MS5803_I2C.h>
#include <Adafruit_Sensor.h>
#include "Adafruit_BMP3XX.h"
int pressure_abs;
int airPressure;
MS5803 sensor(ADDRESS_HIGH);
Adafruit_BMP3XX bmp; // I2C
// Licznik pakietów
int counter = 0;
String message;
void setup() {
// Programowy reset wyświetlacza OLED
pinMode(DONEPIN, OUTPUT);
digitalWrite(DONEPIN, LOW);
delay(20);
// Inicjalizacka wyświetlacza OLED
Wire.begin(OLED_SDA, OLED_SCL);
// Inicjalizacja portu szeregowego
Serial.begin(115200);
while (!Serial);
Serial.println("BMP388 test");
sensor.reset();
sensor.begin();
pressure_abs = sensor.getPressure(ADC_4096);
if (!bmp.begin()) {
Serial.println("Could not find a valid BMP3 sensor, check wiring!");
while (1);
}
Serial.println("LoRa Sender Test");
// Piny SPI transceivera LoRa
SPI.begin(SCK, MISO, MOSI, SS);
// Inicjalizacja transceivera LoRa
LoRa.setPins(SS, RST, DIO0);
if (!LoRa.begin(BAND)) {
Serial.println("Starting LoRa failed!");
while (1);
}
Serial.println("LoRa Initializing OK!");
delay(2000);
bmp.setTemperatureOversampling(BMP3_OVERSAMPLING_8X);
bmp.setPressureOversampling(BMP3_OVERSAMPLING_4X);
bmp.setIIRFilterCoeff(BMP3_IIR_FILTER_COEFF_3);
}
void loop() {
if (! bmp.performReading()) {
Serial.println("Failed to perform reading :(");
return;
}
pressure_abs = sensor.getPressure(ADC_4096);
bmp.performReading();
airPressure = bmp.pressure / 100;
Serial.print("Temperature = ");
Serial.print(bmp.temperature);
Serial.println(" *C");
Serial.print("Pressure = ");
Serial.print(bmp.pressure / 100.0);
Serial.println(" hPa");
Serial.println();
Serial.print("Underwater Sensor:");
Serial.print(pressure_abs);
Serial.println(" hPa");
Serial.print("Sending packet: ");
Serial.println(counter);
message = String(airPressure) + "/" + String(pressure_abs) + "#";
delay(1000);
// Wyślij pakiet LoRa
LoRa.beginPacket();
LoRa.print(message);
LoRa.print(" ");
LoRa.print(counter);
LoRa.endPacket();
counter++;
delay(10000);
while(1) {
digitalWrite(DONEPIN, HIGH);
delay(1);
digitalWrite(DONEPIN, LOW);
delay(1);
}
}
Jednostka z interfejsem LoRa korzysta z tych samych bibliotek do obsługi sensorów. Wyłączono programowo ekran OLED, aby oszczędzać energię w systemie. Biblioteka obsługująca moduł LoRa automatycznie konfiguruje częstotliwość pracy interfejsu zależnie od kraju w jakim pracuje. Następnie tworzy ciąg danych z separatorami, które umożliwiają wysyłanie odczytów czujnika w jednym podejściu, minimalizując obciążenie interfejsu. Następnie aktywuje pin, aby odłączyć zasilanie od mikrokontrolera, w celu oszczędzania energii. Na listingu 2 znajdują się fragmenty szkicu Arduino IDE, do obsługi transceivera LoRa.
#include <SPI.h>
#include <LoRa.h>
#include <WiFi.h>
#include <WiFiClient.h>
#include <BlynkSimpleEsp32.h>
#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>
// Definicja pinów, używanych przez transceiver LoRa
#define SCK 5
#define MISO 19
#define MOSI 27
#define SS 18
#define RST 14
#define DIO0 26
int counter = 0;
#define BAND 866E6
char auth[] = "NeLeTEk53gFyKePf0aCyuqZEUCtT-TEz";
// Dane do logowania do sieci Wi-Fi.
char ssid[] = "";
char pass[] = "";
BlynkTimer timer;
// Piny ekranu OLED
#define OLED_SDA 4
#define OLED_SCL 15
#define OLED_RST 16
#define SCREEN_WIDTH 128 // szerokość ekranu OLED w pikselach
#define SCREEN_HEIGHT 64 // wysokość ekranu OLED w pikselach
Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, OLED_RST);
String airPressureS;
String pressure_absS;
int airPressure;
int pressure_abs;
String LoRaData;
void myTimerEvent()
{
// Możliwe jest wysłanie dowolnej wartości w dowolnym czasie
// ale nie rekomenduje się wysyłania więcej niż 10 na sek.
Blynk.virtualWrite(V5, airPressure);
Blynk.virtualWrite(V4, pressure_abs);
display.clearDisplay();
display.setCursor(0,0);
display.print("Sending packet:");
display.setCursor(0,30);
display.print(LoRaData);
display.display();
}
void setup() {
// Programowy reset wyświetlacza OLED
pinMode(OLED_RST, OUTPUT);
digitalWrite(OLED_RST, LOW);
delay(20);
digitalWrite(OLED_RST, HIGH);
// Inicjalizacka wyświetlacza OLED
Wire.begin(OLED_SDA, OLED_SCL);
if(!display.begin(SSD1306_SWITCHCAPVCC, 0x3c, false, false)) { // Adres 0x3C dla wyświetlacza 128x32
Serial.println(F("SSD1306 allocation failed"));
for(;;); // nieskończona pętla
}
Blynk.begin(auth, ssid, pass);
timer.setInterval(60000L, myTimerEvent);
display.clearDisplay();
display.setTextColor(WHITE);
display.setTextSize(1);
display.setCursor(0,0);
display.print("LORA RECEIVER ");
display.display();
// Inicjalizacja portu szeregowego
Serial.begin(115200);
Serial.println("LoRa Receiver Test");
// Piny SPI transceivera LoRa
SPI.begin(SCK, MISO, MOSI, SS);
// Inicjalizacja transceivera LoRa
LoRa.setPins(SS, RST, DIO0);
if (!LoRa.begin(BAND)) {
Serial.println("Starting LoRa failed!");
while (1);
}
Serial.println("LoRa Initializing OK!");
display.setCursor(0,10);
display.println("LoRa Initializing OK!");
display.display();
}
void loop() {
// Parsowanie pakietów
Blynk.run();
timer.run(); // Inicjalizacja BlynkTimer
int packetSize = LoRa.parsePacket();
if (packetSize) {
// Odebranie pakietu
Serial.print("Received packet ");
// Odczyt pakietu
while (LoRa.available()) {
LoRaData = LoRa.readString();
Serial.print(LoRaData);
}
counter ++;
int pos1 = LoRaData.indexOf('/');
int pos2 = LoRaData.indexOf('#');
airPressureS = LoRaData.substring(0,pos1);
pressure_absS = LoRaData.substring(pos1 + 1, pos2);
airPressure = airPressureS.toInt();
pressure_abs = pressure_absS.toInt();
// Wydruk RSSI pakietu
int rssi = LoRa.packetRssi();
Serial.print(" with RSSI ");
Serial.println(rssi);
// Wyświetlanie informacji
display.clearDisplay();
display.setCursor(0,0);
display.print("LORA RECEIVER");
display.setCursor(0,20);
display.print("Received packet:");
display.setCursor(0,30);
display.print(LoRaData);
display.setCursor(0,40);
display.print("RSSI:");
display.setCursor(30,40);
display.print(rssi);
display.setCursor(0,50);
display.print("LoraCount:");
display.setCursor(60,50);
display.println(counter);
display.display();
}
}
Na listingu 3 zaprezentowano kod programu, odpowiedzialnego za działanie odbiornika LoRa. Rozbija on odebrane słowo i wysyła zdekodowane informacje do aplikacji Blynk przez zawsze dostępne łącze Wi-Fi. Analogicznie jak w przypadku GSM, aplikacja Blynk służy do zbierania i prezentacji danych. Odbiornik jest niewiarygodnie mały – mieści się w obudowie zasilacza wtyczkowego, wraz z systemem zasilania z 230 VAC.
Przykładowe pomiary
Malutka powierzchnia czujnika MS5803 wychwytuje ciśnienie z dużą dokładnością – całą siłę nacisku z góry. Obejmuje to ciśnienie powietrza jak i wody, znajdującej się nad sensorem. Okresowe zmiany wysokości oceanu – takie jak fale – oraz zmiany ciśnienia powietrza, spowodowane burzami nad oceanem, mają wpływ na odczyt ciśnienia. Dlatego nad poziomem wody znajduje się dodatkowy czujnik ciśnienia barometrycznego, w obudowie układu (dlatego nie może być ona w 100% szczelna). Sensor ten służy do korekcji pomiarów względem ciśnienia atmosferycznego, aby możliwy był pomiar tylko ciśnienia wody, znajdującej się nad sensorami.
Sensory poziomu wody są zakotwiczone w oceanie na pewnej głębokości, na której będą cały czas pokryte wodą – nawet podczas odpływu. Głębokość umieszczenia czujników jest dowolna, ponieważ będą mierzyć tylko zmianę wysokości słupa wody, a nie wysokość bezwzględną. Autor użył obciążnika z zamocowaną liną i pływakiem, aby zamontować sensor na ustalonej, stałej głębokości – około kilku metrów. Nadajnik GSM/LoRa zainstalowany został na pobliskiej łodzi, ale można zamieścić go na pomoście, czy innym elemencie nabrzeża.
Wykres z rysunku 2 pokazuje porównanie zmierzonych danych, z wykresem udostępnianym przez NOAA (Narodowa Służba Oceaniczna i Atmosferyczna USA) dla tego samego okresu. Zgodność danych jest bardzo wysoka. Układ bez problemu działał przez cały miesiąc na zasilaniu bateryjnym. Nawet bardzo energochłonny moduł GSM nie rozładował do końca akumulatora, dzięki ciągłemu doładowywaniu z ogniw fotowoltaicznych.
Nikodem Czechowski, EP
Źródło: https://bit.ly/3kqsyjE
Linki:
[1] https://bit.ly/33Oi735
[2] https://bit.ly/2FKrk3H
[3] https://bit.ly/3iHDAAY
