WeatherPi-stacja meteorologiczna zasilana bateriami słonecznymi na Raspberry Pi

Czym jest WeatherPi?

WeatherPi jest zasilaną energią słoneczną stacją pogodową wyposażoną w WiFi, opartą o Raspberry Pi. Jest to wspaniały system do własnoręcznego wykonania. Wszystko jest modyfikowalne, a cały kod źródłowy jest udostępniony do modyfikacji. Najważniejsze funkcje to systemu:

Monitorowanie do 20 różnych parametrów środowiskowych.
Całkowicie zasilany energią słoneczną.
Całą historia przechowywana w bazie danych MySQL.
Monitoruje i raportuje dane dotyczące systemu zasilania bateriami słonecznymi - doskonałe do poznania systemów fotowoltaicznych.
Całkowicie zamknięty system z wbudowanym układem monitorowania na wypadek zapadów zasilania.
Może być zdalnie modyfikowany.
Można pobierać dane zdalnie na komputer PC.
Można zmodyfikować system, tak aby wysyłał SMSy, Twitty czy inne komunikaty.

Poniżej znajduje się opis w jaki sposób skonstruowano ten system

Krok 1: schemat blokowy systemu



Schemat blokowy WeatherPi wygląda o wiele bardziej skomplikowanie, niż jest w rzeczywistości.

Pierwszą rzeczą na jaką trzeba zwrócić uwagę to dwie osobne płytki - WeatherPiArduino oraz SunAirPlus - na których zawarte jest dużo elementów z powyższego

schematu. Druga sprawa to fakt, że wszystkie sensory (po lewej stronie diagramu) podłączane są do płytki WeatherPiArduino, co upraszcza wszystkie połączenia.

Podsystemy

System zasilania stacji wykorzystuje kontroler SunAirPlus, który odpowiedzialny jest za ogniwa słoneczne, ładowanie baterii i stabilizację napięcia 5 V.

Posiada on także sensory, pozwalające na pomiar jakie jest napięcie i prąd baterii słonecznych, ile z tego idzie do zasilania, a ile do baterii. Warto

zbierać te dane! Dodatkowo system ten zawiera sprzętowego watchdoga i system kontroli zasilania USB, który fizycznie odłącza zasilanie w momencie zapadu, po

tym jak Raspberry Pi wyłączy się programowo.

System sensorów wykorzystuje moduł WeatherPiArduino, jako podstawę. Do niego podłączono dodatkowe sensory pozwalające na pomiar prędkości i kierunku wiatru,

detekcja deszczu i wyładowań atmosferycznych, a także temperatury i wilgotności.

Oprogramowanie całego systemu, pracujące na Raspberry Pi napisano w Pythonie. Zbiera ono dane, przechowuje je w bibliotece MySQL, rysuje wykresy i zajmuje

się innymi istotnymi sprawami związanymi z poprawnym działaniem systemu.

Krok 2: Zestaw sensorów



WeatherPi wyposażony jest w sensory zbierające następujące dane:

Prędkość i kierunek wiatru.
Obecność deszczu.
Temperatura i wilgotność na dworze.
Detekcja wyładowań atmosferycznych.
Ciśnienie barometryczne (i wysokość n.p.m.).
Temperatura i wilgotność wewnątrz obudowy.

Można dodać ich więcej, korzystając z szyny I?C lub konwerterów ADC. Dodać można czujniki UV, kurzu lub koloru (do monitorowania skażenia). Zestaw sensorów

wpięty jest w płytkę WeatherPiArduino, ale istnieje wiele podobnych, pozwalających na to samo.

Krok 3: co jest na szynie I?C?



WeatherPI intensywnie wykorzystuje ten szeregowy interfejs do komunikacji z RPi. Czasami zdarzać mogą się konflikty adresów, jeśli ma się pecha i włączy się

dwa sensory na tej samej szynie I?C. Dlatego też dodano do układu multiplekser I?C, co pozwala wykorzystać sensory o tych samych adresach. Aktualna lista

sensorów WeatherPi, wraz z adresami, wygląda następująco:



Tak wygląda lista, a poniżej pokazano wyjście, widziane przez RPi z multipleksera, WeatherPi wykorzystuje tylko szyny 0 i 1 w tym przypadku:

[code:1]Test SDL_Pi_TCA9545 Version 1.0 - SwitchDoc Labs

Sample uses 0x73
Program Started at:2015-05-10 20:00:56

-----------BUS 0-------------------
tca9545 control register B3-B0 = 0x1
ignore Interrupts if INT3' - INT0' not connected
tca9545 control register Interrupts = 0xc
0 1 2 3 4 5 6 7 8 9 a b c d e f
00: 03 -- -- -- -- -- -- -- -- -- -- -- --
10: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
20: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
30: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
40: 40 -- -- -- -- -- -- -- -- 49 -- -- -- -- -- --
50: 50 -- -- -- -- -- 56 -- -- -- -- -- -- -- -- --
60: -- -- -- -- -- -- -- -- 68 -- -- -- -- -- -- --
70: -- -- -- 73 -- -- -- 77

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

-----------BUS 1-------------------
tca9545 control register B3-B0 = 0x2
ignore Interrupts if INT3' - INT0' not connected
tca9545 control register Interrupts = 0xe
0 1 2 3 4 5 6 7 8 9 a b c d e f
00: -- -- -- -- -- -- -- -- -- -- -- -- --
10: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
20: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
30: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
40: 40 -- -- -- -- -- -- -- 48 -- -- -- -- -- -- --
50: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
60: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
70: -- -- -- 73 -- -- -- --

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

-----------BUS 2-------------------
tca9545 control register B3-B0 = 0x4
ignore Interrupts if INT3' - INT0' not connected
tca9545 control register Interrupts = 0xc
0 1 2 3 4 5 6 7 8 9 a b c d e f
00: -- -- -- -- -- -- -- -- -- -- -- -- --
10: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
20: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
30: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
40: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
50: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
60: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
70: -- -- -- 73 -- -- -- --

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

-----------BUS 3-------------------
tca9545 control register B3-B0 = 0x8
ignore Interrupts if INT3' - INT0' not connected
tca9545 control register Interrupts = 0xc
0 1 2 3 4 5 6 7 8 9 a b c d e f
00: -- -- -- -- -- -- -- -- -- -- -- -- --
10: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
20: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
30: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
40: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
50: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
60: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
70: -- -- -- 73 -- -- -- --

-----------------------------------
<\pre>[/code:1]

Krok 4: sięgnąć po energie słoneczną



Pierwszą rzeczą, jaką trzeba zrobić projektując system zasilany słonecznie, jest zaprojektować układ zasilania. Zadać trzeba sobie trzy ważne pytania:

Ile potrzebuję mocy?
Ile paneli słonecznych mi potrzeba?
Jaka musi być pojemność baterii?

Zatem obliczmy ile potrzebne jest nam mocy. Chcemy aby nasz system działał cały dzień i co najmniej trzy godziny po zachodzie słońca i trzy godziny przed

jego zajściem. Dodatkowy wpływ mają także koszty instalacji.

Poniższa tabela podsumowuje zużycie mocy przez RPi z kartą WiFi. W każdym układzie wyłączony jest port HDMI, co daje 20 mA prądu oszczędności.



We wszystkich pomiarach uwzględniono kartę WiFi, która pobiera aż 60 mA. Dane w nawiasach mówią o poborze bez tej karty. Na tej podstawie wybrano wersję A+.

Akumulator (LiPo) w systemie ma około 6600 mAh.

Założenia:

Dwa panele fotowoltaiczne po 3,4 W (6 V/ 530 mA) - 6,8 W mocy.
8 godzin słońca dziennie, dających 70% mocy maksymalnej ogniw, 85% efektywności przetwarzania zasilania.
Raspberry Pi Model A+ pobierające średnio 195mA.
Raspberry Pi Model A+ pracujące 24/h dobę.
Baterie LiPo o pojemności 6600mAh.

Zatem wyliczmy:

PiRunTime = (8 Hours * 70% * 1060mA) *85% / (195mA) = 25 hours

A naszym celem było 24h, więc system będzie działał. 16h pracy w nocy pobierze 3670 mAh, co jest znacznie mniejszą wartością niż 6600 mAh pojemności. I to

wszystko bez minimalizowania poboru prądu np. przez kartę WiFi. Dodatkowo warto zauważyć, że w ciągu dnia jesteśmy w stanie naładować baterię do prawie pełna

(600 mAh). Zastosowanie większej baterii nie zmieni w zasadzie działania systemu. Zatem układ jest w stanie poprawnie działać 24h/dobę. Oczywiście, jeśli

ilość dostępnego słońca jest mniejsza, to trzeba ponownie zweryfikować te założenia.

Krok 5: system zasilający



System zasilania Weather Pi składa się z 4 elementów:

Dwóch baterii słonecznych
Akumulatora LiPo 6600 mAh
Kontrolera SunAirPlus Solar zasilającego RPi
Płytki PowerControl na USB.

Moduł SunAirPlus posiada wbudowany układy INA3221 i ADS1015. Pierwszy z nich to trzykanałowy monitor napięcia i prądu, a drugi jest czterokanałowym 12 bitowy

przetwornik ADC, oba z interfejsem I?C. Pozwala to na monitorowanie prądów i napięć w systemie w czasie rzeczywistym.

Poniżej zaprezentowano przykładowy zrzut danych z systemu monitorowania układów zasilania.

[code:1]Test SDL_Pi_INA3221 Version 1.0 - SwitchDoc Labs

Sample uses 0x40 and SunAirPlus board INA3221
Will work with the INA3221 SwitchDoc Labs Breakout Board


------------------------------
LIPO_Battery Bus Voltage: 4.15 V
LIPO_Battery Shunt Voltage: -9.12 mV
LIPO_Battery Load Voltage: 4.14 V
LIPO_Battery Current 1: 91.20 mA

Solar Cell Bus Voltage 2: 5.19 V
Solar Cell Shunt Voltage 2: -73.52 mV
Solar Cell Load Voltage 2: 5.12 V
Solar Cell Current 2: 735.20 mA

Output Bus Voltage 3: 4.88 V
Output Shunt Voltage 3: 48.68 mV
Output Load Voltage 3: 4.93 V
Output Current 3: 486.80 mA[/code:1]

Do projektu dodać można silnik lub serwo, które pozwolą podążać za ruchem słońca, dzięki zastosowania fotorezystorów, co jeszcze bardziej zwiększy ilość

dostępnej mocy w układzie.

Płytka PowerController zasadniczo jest przekaźnikiem półprzewodnikowym, który pozwala na wyłączanie i włączanie zasilania RPi. Podłączona jest bezpośrednio

pomiędzy baterią a RPi - układ załącza się dopiero gdy napięcie na baterii przekracza ok 3,8 V, a dzięki histerezie, nie nastąpi sytuacja w której system

będzie załączał się od razu po naładowaniu baterii, gdyż to najprostsza droga do uszkodzenia karty SD w komputerze.

Krok 6: bezpieczne załączanie i wyłączanie Raspberry Pi



Problem zapadów

Zapady napięcia zasilającego, są poważnym problemem w systemach zasilanych solarnie, poniżej opiszemy w jaki sposób poradzono sobie z tym w tym projekcie.

Prosty kontroler zasilania pozwala na jego rozwiązanie.

Czemu się tym martwić? może zdarzyć się szereg chmurnych dni, czy coś przesłoni słońce na dłużej. Można kompensować to dodając więcej paneli, ale nie jest to

dobre rozwiązanie.

Wyłączanie RPi

Wyłączanie komputera jest dosyć proste, gdy napięcie na baterii spadnie poniżej pewnego progu, po prostu zrealizowana zostanie komenda ?sudo shutdown -h now?

i Raspberry Pi się wyłączy. Jako próg napięcia wybrano w projekcie 3,5 V.

Trzeba pamiętać, że monitorować należy napięcie na baterii, a nie napięcie zasilania 5 V w układzie, ponieważ pomiędzy baterią a układem jest przetwornica

step-up. Oznacza to, że monitorując 5 V, możemy nie zauważyć że kończy nam się zasilanie i gdy napięcie baterii spadnie poniżej pewnego progu to przetwornica

się wyłączy i napięcie 5 V po prostu zniknie nagle.

Uruchamianie RPi

Nie można po prostu pozwolić, aby kontroler zasilania uruchomił komputer. Problem polega na tym, że napięcie zasilające będzie się zmieniać, do czasu aż

bateria będzie dostatecznie naładowana. Gdy podłączy się komputer, obciąży on baterie i napięcie spadnie, więc RPi znowu się wyłączy. Ciągłe resetowanie

komputera prowadzi do uszkodzenia karty SD.

Można ten problem rozwiązać na kilka sposobów, np. wykorzystując bardziej odporne na to Arduino do odłączania RPi od zasilania, poprzez MOSFET, gdy zasilanie

nie jest dostatecznie ustabilizowane. Ale nie chcemy dodawać do systemu kolejnego układu, więc wybieramy drugą możliwość - wykorzystanie modułu kontroli

zasilania USB. Jest to też tańsze rozwiązanie problemu zapadów napięcia i następującego po nich uruchamiania RPi gdy napięcie baterii jest dostatecznie

wysokie. Jest to możliwe dzięki zastosowaniu histerezy. Funkcja ta wbudowana jest w prostą przejściówkę, włączaną pomiędzy kabel USB wychodzący z modułu

SunAir a wejście zasilania RPi.

Płytka ta zawiera w sobie przekaźnik elektroniczny, pozwalający na odłączanie zasilania od dowolnego ukłądu podłączonego do tego systemu. Jest on bardzo

prosty do podłączenia, wystarczy podpiąć do niego linię kontrolną - wyjście cyfrowe ogólnego przeznaczenia (GPIO) lub napięcie z baterii LiPo. Jeśli będzie

tam stan niski (napięcie poniżej ok. 3,3 V) to układ będzie wyłączony, jeśli będzie stan wysoki (napięcie powyżej 3,8 V) to przekaźnik się załączy i na

wyjściu USB obecne będzie napięcie zasilania (5 V). Takie rozwiązanie zapewnia także histerezę załączania, ponieważ przekaźnik załącza się dopiero po

przekroczeniu wyższego progu, niż wyłączenie. Zasadniczo nie potrzebuje on programowej kontroli, wszystko dzieje się automatycznie. Dodatkowo moduł ten

wysyłą informacje do komputera, żeby się wyłączył, zanim odłączy od niego zasilanie. Odłączanie zasilania jest istotne, gdyż nawet wyłączony komputer pobiera

ok 100 mA!.

Krok 7: lista elementów



Żaden projekt nie jest kompletny bez listy zakupów, poniższe to tylko sugestie tego co można wykorzystać, ale istnieje wiele innych płytek! jeśli chce się

coś zamieniać, koniecznie trzeba sprawdzać kompatybilność. Firma SwitchDoc Labs daje 10% rabatu na swoje elementy pod kodami 6NOFQ9UW na Amazon.com i 672E608

na Tindie.com.

Lista części:

[code:1] WeatherRack Weather Sensors
BUD NEMA Box z Amazon.com
Dwa ogniwa fotowoltaicyne od VoltaicSystems
Raspberry Pi A+
Karta WiFi na USB kompatybilna z Raspberry Pi
Kontroler SunAirPlus Solar
USB Control
4 Channel I?C Mux
SwitchDoc Labs Dual WatchDog Timer
WeatherPiArduino
Embedded
DS3231
AM2315
BMP180
Adafruit HTU21D-F
Adafruit 32KB FRAM
Adafruit ADS1015
Adafruit PKCELL - bateria litowo jonowa - 3.7V 6600mAh
Waterproof 8 Pin Plug from Amazon.com
DWa podwójne terminale śrubowe z Amazon.com
RasPiConnect Control Panel[/code:1]

Krok 8: składanie całości



Jak przy większości projektów, dobrze jest złożyć prototyp na płytce, zanim umieści się wszystko w obudowie. W przypadku WeatherPi elementy zostałt ułożone

na stole i połączone kablami. Po upewnieniu się że wszystko działa poprawnie, układ umieszczony został w odpowiedniej obudowie. Umiejscowienie poszczególnych elementów w obudowie było bezproblemowe, a rozmieszczenie poszczególnych modułów podyktowane chęcia skrócenia odległości pomiędzy ogniwami fotowoltaicznymi a modułem zasilania. Wsyzstkie śruby zostały następnie uszczelnione silikonem. Kable wychodzące z obudowy zostały przepuszczone przez odpowiednie przepusty, któe może nie są w pełni wodoodporne, ale zapewniają dobry uwchwyt i po pokryciu silikonem są dostatecznie szczelne.

Krok 9: oprogramowanie w Pythonie



Dużą częścią projektu jest oprogramowanie. Całe oprogramowanie tego projektu dostępne jest na portalu github, wraz z wszystkimi wykorzystanymi bibliotekami do układów I?C. Ponadto wymagane jest jeszcze zainstalowanie biblioteki do obsługi MySQL oraz biblioteki MatPlotLib. Samo oprogramowanie jest dosyć proste i pracuje w pętli sprawdzającej sensory "co 15 sekund". Poniżej zaprezentowano kod głównej pętli programu:



Krok 10: wykorzystanie RasPiConnect do konstrukcji panelu głónego



Wykorzystany został RasPiConnect do konstrukcji panelu graficznego programu w tym projekcie. Pozwala on na umieszczanie na ekranie kontrolek, przełączników, wykresów itp. do któych dostęp jest z poziomu iPhona lub iPada. Oprogramowanir o działa i na RPi i na Arduino. Kod wykorzystany do panelu graficznego WeatherPi umieszczony jest także na githubie, skąd ożna go pobrać.

Krok 11: wyniki!



WeatherPi jest już na dworze od dwóch tygodni. PRacuje perfekcyjnie, co widać na powyższych obrazkach. Baterie są z powodzeniem ładowane przez baterie słoneczne, a potem zasilają układ, gdy słońce chowa się za domem. Z uwagi na to że układ znajduje się w dość zacienionym miejscu to nie dostaje 8 h słońca, przez co nie jest w stanie działać 24h/dobę, ale po przesunięciu go w docelowe miejsce na dachu domu, powinien być wystawiony na słońce przez około 12h, o ile nie będzie się ono chować za chmurami.

Źródło:

http://www.instructables.com/id/Create-Your-Own-Solar-Powered-Raspberry-Pi-Weather/?ALLSTEPS
http://www.switchdoc.com/2015/05/weatherpi-instructable-released-solar-powered-raspberry-pi/
http://hackedgadgets.com/2015/05/12/raspberry-pi-weather-station/