Accurate Regenvoorspelling: Bouw een Arduino-systeem met Python & Keras

Onderdelen en benodigdheden

Kleine plastic doos met afneembare deksels (mijn heeft schroeven)	×	1
Drie AAA-batterijhouder	×	1
Drie AAA oplaadbare batterijen	×	1
6V klein zonnepaneel	×	1
SparkFun Arduino Pro Mini 328 - 5V/16MHz	×	1
1N4004-diode	×	1
Algemene NPN-transistor	×	1
Regensensor	×	1
HC-12 seriële communicatiemodule	×	1
HC-12 USB-seriële module	×	1
SparkFun Atmospheric Sensor Breakout - BME280	×	1
BH1750 lichtsensor	×	1
PCB, draden, soldeer, KF301-2P schroefconnector, male/female PCB-connectoren, lijm	×	1
3.3V-spanningsregelaar	×	1

Benodigde tools en machines

• USB naar seriële FTDI-adapter FT232RL
• Boormachine
• Solderbout
• Schroevendraaiers

Over dit project

Eerst een paar woorden over dit project: de motivatie, de betrokken technologieën en het eindproduct dat we gaan bouwen.

Het grote doel is om regen in de toekomst te voorspellen (we proberen 6 uur vooruit). De voorspelling is een ja of nee (boolean in programmeertaal). Ik heb naar tutorials gezocht op dit onderwerp en geen enkele gevonden die in alle opzichten compleet is. Mijn aanpak zal dit op een heel nieuw niveau tillen en in elk aspect ingaan. Daarvoor gaan we:

• Bouwen van het weerstation zelf. Het station moet volledig off-grid zijn met een zonnepaneel en een extreem lage stroomverbruikmodus (enkele tientjes microampere per uur)
• Programmeren van het station zodat het gegevens verzamelt en elke 10 minuten doorstuurt naar een basestation
• Verzamelen van de gegevens op de basestation en opslaan (in een database)
• Gebruik van neurale netwerken (Keras-bibliotheek) en andere Python-bibliotheken zoals pandas om de data te filteren, te reinigen en te verwerken, en vervolgens in een neuraal netwerk te voeren om een "model" te trainen voor regenvoorspelling
• Ten slotte voorspellen of het zal regenen in de komende 6 uur en gebruikers per e-mail notificeren

Ik heb persoonlijk dit weerstation gebruikt om data te verzamelen (je kunt de data in de volgende stappen downloaden). Met slechts ongeveer 600 dagen weergegevens kan het systeem voorspellen of het zal regenen of niet in de komende 6 uur met een nauwkeurigheid van ongeveer 80%, afhankelijk van de parameters, wat niet slecht is.

Deze tutorial begeleidt je door alle benodigde stappen om regenval vanaf nul te voorspellen. We maken een eindproduct dat een praktisch werk doet, zonder externe weer- of machine learning API's. We leren onderweg hoe je een praktisch weerstation bouwt (laag vermogen en off-grid) dat echt data verzamelt over lange periodes zonder onderhoud. Daarna leer je hoe je het programmeert met Arduino IDE. Hoe je data verzamelt in een database op een basestation (server). En hoe je de data verwerkt (Pandas) en neurale netwerken (Keras) toepast en vervolgens de regenval voorspelt.

Stap 1: Onderdelen en tools voor het bouwen van het station

Onderdelen:

1. Kleine plastic doos met afneembare deksels (mijn heeft schroeven). De doos moet groot genoeg zijn voor de kleine componenten en batterijen. Mijn doos is 11 x 7 x 5 cm
2. Drie AAA-batterijhouder
3. Drie AAA oplaadbare batterijen
4. 6V klein zonnepaneel
5. Arduino Pro Mini 328p
6. Een diode, 1N4004 (om omgekeerde stroom van de batterijen naar het paneel te voorkomen)
7. Een kleine NPN-transistor en 1k-weerstand (voor het in- en uitschakelen van de voeding naar de componenten)
8. Een regensensor
9. HC-12 seriële communicatiemodule
10. HC-12 USB-seriële module (voor de basestation)
11. BME280 Bosch-sensormodule (voor vochtigheid, temperatuur, druk)
12. BH1750 lichtmeetmodule
13. PCB, draden, soldeer, KF301-2P plug-in schroefconnector, male/female PCB-connectoren, lijm
14. 3.3V-regelaar
15. Een basestation: een PC of een development board dat continu draait. De rol is data verzamelen, het regenvoorspellingsmodel trainen en voorspellen doen

Tools:

1. USB naar seriële FTDI-adapter FT232RL om de Arduino Pro Mini te programmeren
2. Arduino IDE
3. Boormachine
4. Fijnzaag
5. Schroevendraaiers
6. Solderbout
7. Draadknipper

Vaardigheden:

1. Solderen, bekijk deze tutorial
2. Basale Arduino-programmering
3. Linux-serviceconfiguratie, pakketinstallatie
4. Enige programmeervaardigheden

Stap 2: Het weerstation bouwen

Het weerstation bestaat uit de volgende componentensets:

1. de doos met het zonnepaneel erop geklijfd
2. de PCB met de elektronica erbinnen
3. de batterijhouder ook erbinnen
4. de BME280, licht- en regensensoren aan de buitenkant

1. De doos heeft 4 gaten nodig: één voor de zonnepaneldraden, de andere drie voor de sensoren die buiten worden geplaatst. Boor eerst de gaten, ze moeten groot genoeg zijn voor de male-female draden om eruit te steken en naar de sensoren te gaan. Na het boren, kleef het paneel aan één kant van de doos en haal de draden door een gat naar binnen.

2. De PCB zal de Arduino, HC-12, 3.3V-regelaar, diode, transistor, weerstand en twee KF301-2P connectors bevatten.

• Eerst de twee female PCB-connectoren op de PCB solderen voor de Arduino, de male PCB-connectoren aan de Arduino solderen en de Arduino op de PCB plaatsen
• De Arduino-led moet verwijderd worden of tenminste één van de pennen. Dit is zeer belangrijk omdat de led een grote hoeveelheid stroom trekt. Wees voorzichtig om andere componenten niet te beschadigen
• De transistor, weerstand en 3.3V-regelaar solderen
• De twee KF301-2P solderen. Één voor het zonnepaneel, de ander voor de batterijhouder
• Drie female PCB-connectoren solderen: voor de lichtsensor, BME280 en regensensor
• Kleine draden solderen om alle PCB-componenten te verbinden (check de afbeeldingen en het Fritzing-schema)

3. Plaats 3 opgeladen AAA NiMH-batterijen in de houder en plaats deze in de doos, verbind de draden met de KF301-2P-connector.

4. Verbind de BME280- en lichtsensoren van buitenaf met hun bijbehorende male-connectoren.

Voor de regensensor, soldeer drie draden (Gnd, Vcc, signaal) eraan, en aan de andere kant male pinnen die naar binnen gaan naar de bijbehorende male-connectoren.

Het laatste is het station op zijn definitieve positie plaatsen. Ik heb een positie gekozen die beschut is tegen regen en sneeuw. Ik heb langere draden voor de regensensor gekozen en deze apart in de regen op een stevige steun geplaatst. Voor de hoofddoos heb ik een speciaal tape met lijm gebruikt (check de afbeeldingen) maar alles wat de doos vast houdt werkt.

Stap 3: Arduino-code

In deze stap leer je welke externe bibliotheken nodig zijn, we bespreken de code en hoe het werkt, en natuurlijk kun je het downloaden of kopiëren in de Arduino IDE en uploaden naar het weerstation.

De rol van het weerstation is om elke 10 minuten sensorgegevens door te sturen naar een basestation.

Wat het weerstation-programma doet:

1. Lees sensordata (vochtigheid, temperatuur, druk, regen, licht, spanning)
2. Verstuur de gecodeerde data via een tweede software-seriële lijn. De gecodeerde data ziet er zo uit: H1:78|T1:12|PS1:1022|L1:500|R1:0|V1:4010| (vochtigheid station 1: 78%, temperatuur: 12°C, druk: 1022 hPa, licht: 500 lux, regen: 0, spanning: 4010 mV)
3. Schakel de auxiliaire componenten uit: sensoren en communicatieapparaat
4. Zet de Arduino in slaapmodus voor 10 minuten (verbruikt <50 microampere)
5. Schakel componenten aan en herhaal stappen 1-4

Extra: als de spanning boven 4.2V is, gebruikt de Arduino de normale slaapfunctie "delay(milliseconden)". Dit verhoogt het stroomverbruik en verlaagt de spanning snel. Dit voorkomt effectief overladen van de batterijen door het zonnepaneel.

Je kunt de code van mijn GitHub-repository halen: GitHub-link

Of kopieer het onderstaande. Verwijder de regel met "transmitSenzorData("V", sensors.voltage);"

#include "LowPower.h"
#include "SoftwareSerial.h"
#include "Wire.h"
#include "Adafruit_Sensor.h"
#include "Adafruit_BME280.h"
#include "BH1750.h"

SoftwareSerial serialComm(4, 5); // RX, TX
Adafruit_BME280 bme;
BH1750 lightMeter;
const byte rainPin = A0;
byte sensorsCode = 1;
int voltageDeepSleepThreshold = 4200;
const byte peripherialsPowerPin = 6;
char buffer[] = {' ',' ',' ',' ',' ',' ',' '};

struct sensorData {
  byte humidity;
  int temperature;
  byte rain;
  int pressure;
  long voltage;
  int light;
};

sensorData sensors;

void setup() {
  Serial.begin(9600);
  serialComm.begin(9600);
  pinMode(peripherialsPowerPin, OUTPUT);
  digitalWrite(peripherialsPowerPin, HIGH);
  delay(500);
  if (!bme.begin()) {
    Serial.println("Could not find a valid BME280 sensor, check wiring!");
    while (1) { customSleep(100); }
  }
  Serial.println("Initialization finished succesfully");
  delay(50);
  digitalWrite(peripherialsPowerPin, HIGH);
}

void loop() {
  updateSenzors();
  transmitData();
  customSleep(75);
}

void updateSenzors() {
  bme.begin();
  lightMeter.begin();
  delay(300);
  sensors.temperature = bme.readTemperature();
  sensors.pressure = bme.readPressure() / 100.0F;
  sensors.humidity = bme.readHumidity();
  sensors.light = lightMeter.readLightLevel();
  sensors.voltage = readVcc();
  sensors.rain = readRain();
}

void transmitData() {
  emptyIncommingSerialBuffer();
  Serial.print("Temp:"); Serial.println(sensors.temperature);
  Serial.print("Humid:"); Serial.println(sensors.humidity);
  Serial.print("Pressure:"); Serial.println(sensors.pressure);
  Serial.print("Light:"); Serial.println(sensors.light);
  Serial.print("Voltage:"); Serial.println(sensors.voltage);
  Serial.print("Rain:"); Serial.println(sensors.rain);
  
  transmitSenzorData("T", sensors.temperature);
  transmitSenzorData("H", sensors.humidity);
  transmitSenzorData("PS", sensors.pressure);
  transmitSenzorData("L", sensors.light);
  transmitSenzorData("V", sensors.voltage);
  transmitSenzorData("R", sensors.rain);
}

void emptyIncommingSerialBuffer() {
  while (serialComm.available() > 0) {
    serialComm.read();
    delay(5);
  }
}

void transmitSenzorData(String type, int value) {
  serialComm.print(type);
  serialComm.print(sensorsCode);
  serialComm.print(":");
  serialComm.print(value);
  serialComm.print("|");
  delay(50);
}

void customSleep(long eightSecondCycles) {
  if (sensors.voltage > voltageDeepSleepThreshold) {
    delay(eightSecondCycles * 8000);
    return;
  }
  digitalWrite(peripherialsPowerPin, LOW);
  for (int i = 0; i < eightSecondCycles; i++) {
    LowPower.powerDown(SLEEP_8S, ADC_OFF, BOD_OFF);
  }
  digitalWrite(peripherialsPowerPin, HIGH);
  delay(500);
}

byte readRain() {
  byte level = analogRead(rainPin);
  return map(level, 0, 1023, 0, 100);
}

long readVcc() {
  // Lees 1.1V referentie tegen AVcc
  #if defined(__AVR_ATmega32U4__) || defined(__AVR_ATmega1280__) || defined(__AVR_ATmega2560__)
    ADMUX = _BV(REFS0) | _BV(MUX4) | _BV(MUX3) | _BV(MUX2) | _BV(MUX1);
  #elif defined (__AVR_ATtiny24__) || defined(__AVR_ATtiny44__) || defined(__AVR_ATtiny84__)
    ADMUX = _BV(MUX5) | _BV(MUX0);
  #elif defined (__AVR_ATtiny25__) || defined(__AVR_ATtiny45__) || defined(__AVR_ATtiny85__)
    ADMUX = _BV(MUX3) | _BV(MUX2);
  #else
    ADMUX = _BV(REFS0) | _BV(MUX3) | _BV(MUX2) | _BV(MUX1);
  #endif
  delay(2);
  ADCSRA |= _BV(ADSC);
  while (bit_is_set(ADCSRA,ADSC));
  uint8_t low = ADCL;
  uint8_t high = ADCH;
  long result = (high<<8) | low;
  result = 1125300L / result;
  return result; // Vcc in millivolts
}

Voordat je de code uploadt, download en installeer de volgende Arduino-bibliotheken:

• BH1750-bibliotheek: GitHub
• LowPower-bibliotheek: GitHub
• Adafruit Sensor-bibliotheek: GitHub
• Adafruit BME280-bibliotheek: GitHub

Als je niet weet hoe dat moet, bekijk deze tutorial.

Stap 4: De basestation voorbereiden

De basestation bestaat uit een Linux-computer (desktop, laptop of development board) met de HC-12 USB-module aangesloten. De computer moet altijd aanstaan om elke 10 minuten data van het station te ontvangen.

Ik gebruikte mijn laptop met Ubuntu 18.

Installatiestappen:

1. Installeer Anaconda. Anaconda is een Python-pakketbeheerder en maakt het gemakkelijk om met dezelfde afhankelijkheden te werken. We kunnen de Python-versie en elke pakketversie controleren. Zie deze tutorial (stappen 1-8).
2. Installeer MongoDB. MongoDB zal onze hoofddatabase zijn. Het slaat data op over alle sensorentijdreeksen. Het is schema-loos en voor ons doel makkelijk te gebruiken. Zie installatiehandleiding. Ik gebruikte MongoDB 3.4.6.
3. Download het project: GitHub. We gebruiken de weather-predict-map.

   sudo apt-get install git
   git clone https://github.com/danionescu0/home-automation.git

4. Maak en configureer Anaconda-omgeving:

   cd weather-predict
   conda create --name weather python=3.6.2
   conda activate weather
   pip install -r requirements.txt

   Dit creëert een nieuwe Anaconda-omgeving en installeert de benodigde pakketten: Keras, pandas, pymongo, sklearn, etc.

Project configureren

Het configuratiebestand zit in de weather-predict-map en heet config.py

1. Als je MongoDB op een andere host/poort hebt geïnstalleerd, wijzig "host" of "port" in:

   mongodb = { 'host': 'localhost', 'port': 27017 }

2. Koppel de HC-12 USB-seriële adapter. Voer ls -l /dev/tty* uit voor en na het insteken. Wijzig de poort in de config indien nodig:

   serial = { 'port': '/dev/ttyUSB0', 'baud_rate': 9600 }

Stap 5: Het weerstation in de praktijk gebruiken

Mijn al verzamelde data importeren

MongoDB heeft een CLI-commando voor importeren vanuit JSON:

mongoimport -d weather -c weather_station --file sample_data/weather_station.json

Let op: als je mijn data combineert met je lokale data, kan de nauwkeurigheid dalen door kleine verschillen in hardware en lokale weerspatronen.

Nieuwe data verzamelen

Een van de rollen van de basestation is binnenkomende data opslaan in de database. Start het luisterproces:

conda activate weather
python serial_listener.py

Elke 10 minuten zou je data moeten zien binnenkomen.

Voorspellingsmodel genereren

Verwerk de data om een model te maken voor toekomstige regenvoorspelling:

conda activate weather
python train.py --days_behind 600 --test-file-percent 10 --datapoints-behind 8 --hour-granularity 6

• --days_behind: hoeveel dagen in het verleden verwerken
• --test-file-percent: percentage data voor testen
• --hour-granularity: hoeveel uur vooruit voorspellen
• --datapoints-behind: wordt verder besproken

Grafieken bekijken

Voor de laatste 10 dagen:

conda activate weather
python graphs --days-behind 10

Voorspellen of het gaat regenen

Voorspel regen en stuur een notificatie-e-mail:

conda activate weather
python predict.py --datapoints-behind 8 --hour-granularity 6 --from-addr een_gmail_adres --from-password gmail_wachtwoord --to-addr een_bestemmings_email

Batch-voorspelling op testdata:

python predict_batch.py -f sample_data/test_data.csv

Gebruik dezelfde parameters als in het train-script. Voor e-mailnotificaties: zet in Gmail "Minder veilige apps toestaan" aan. Je hebt twee e-mailadressen nodig. Voor urenlijks notificaties, voeg het script toe aan crontab.

Stap 6: Hoe het werkt

In deze laatste stap bespreken we verschillende aspecten van de architectuur:

1. Projectoverzicht: algemene architectuur en technologieën
2. Basisbegrippen van machine learning
3. Hoe de data wordt voorbereid (belangrijkste stap)
4. Hoe de neurale netwerk-wrapper API werkt (Keras)
5. Toekomstige verbeteringen

1. Projectoverzicht

Het project heeft twee gescheiden delen: het weerstation (alleen data verzamelen en versturen) en de basestation (verzamelen, trainen, voorspellen).

Voordelen van scheiding:

• Stroomvereisten: als het weerstation ook data verwerkte, zou het substantiële stroom nodig hebben
• Draagbaarheid: door de kleine afmetingen kan het station data verzamelen op een paar honderd meter afstand
• Schaalbaarheid: je kunt meer stations bouwen en verspreiden voor betere data
• Lage kosten: goedkoop om te vervangen als er een verloren gaat of gestolen wordt

Databasekeuze: MongoDB gekozen voor schemaloos, gratis, makkelijke API.

Elke keer dat sensordata wordt ontvangen, wordt het opgeslagen. Een data-entry ziet er zo uit:

{ "_id" : "04_27_2017_06_17", "humidity" : 65, "date" : ISODate("2017-04-27T06:17:18Z"), "pressure" : 1007, "temperature" : 9, "rain" : 0, "light" : 15 }

Data wordt opgeslagen in BSON-formaat (vergelijkbaar met JSON). Geaggregeerd onder een identifier met datum geformatteerd tot minuten.

Data-verwerking en neurale netwerken: Python gekozen vanwege grote community en bibliotheken. Pandas voor datamanipulatie, Keras als high-level neural network wrapper over TensorFlow.

2. Basisbegrippen Machine Learning

Neurale netwerken zijn datastructuren die lijken op hersencellen (neuronen). Neuronen communiceren via elektrische impulsjes door axonen. Als voldoende gestimuleerd, sturen ze een impuls door. Computeralgoritmen proberen dit biologisch proces na te bootsen.

Elke gesimuleerde neuron heeft een "triggerpunt" (bias), elke axoon een gewicht. Na willekeurige initialisatie start een "leerproces": in een lus stimuleren we input-neuronen, propageren signalen door lagen, lezen output, vergelijken met gewenste resultaat, passen gewichten aan, herhalen.

We gebruiken supervised learning: we leren het algoritme inputs EN outputs, zodat het gegeven nieuwe inputs de output kan voorspellen.

3. Data voorbereiden (belangrijkste stap)

Data-voorbereiding omvat:

• Ruw data ophalen
• Data opschonen: verwilderde waarden, afwijkingen verwijderen
• Data groeperen: veel kleine datapunten transformeren naar geaggregeerde datapunten
• Data verrijken: extra aspecten toevoegen afgeleid van eigen data of externe bronnen
• Data splitsen in train- en testdata
• Splitsen in inputs en outputs
• Data schalen tussen 0 en 1

Ruw data ophalen uit MongoDB:

client = MongoClient(host, port).weather.datapoints
cursor = client.find({'$and': [{'date': {'$gte': start_date}}, {'date': {'$lte': end_date}}]})
data = list(cursor)

Data opschonen: Lege waarden droppen: dataframe = dataframe.dropna()

Data groeperen & verrijken: Veel kleine datapunten groeperen in 6-uur intervallen. Per sensor (vochtigheid, regen, temperatuur, licht, druk) berekenen: min, max, gemiddelde, 10/30/70/90 percentielen, aantal stijgingen, dalingen, constante waarden.

Van een dataframe met 10-minuten intervallen naar een dataframe met 6-uur intervallen met veel afgeleide kenmerken.

Nieuwe kolom "has_rain" toevoegen (0 of 1 afhankelijk of regen_gemiddelde > 0.1):

dataframe.insert(loc=1, column='has_rain', value=numpy.where(dataframe['rain_avg'] > 0.1, 1, 0))

Data opschonen (weer): Datumkolom droppen, rijen waar minimum temperatuur < 0 verwijderen (geen sneeuwsensor).

Data verrijken: Voor elke rij kolommen toevoegen die verwijzen naar eerdere rijen (temperatuur_1, temperatuur_2, ...). Optimaal aantal voor 6-uur groeperingen is 8 (48 uur historie).

Data opschonen (nogmaals): Eerste rijen met NaN waarden verwijderen. Huidige datapunt-info droppen (behalve has_rain).

Splitsen in train/test: Via sklearn: train_test_split(dataframe, test_size=percent_test_data)

Inputs/outputs scheiden: X = main_data.iloc[:, 1:].values; y = main_data.iloc[:, 0].values

Data schalen (0-1): Via StandardScaler, model opslaan met joblib.

4. Neuraal netwerk met Keras

Een multi-layer netwerk bouwen met Keras is eenvoudig:

from keras.models import Sequential
from keras.layers import Dense, Dropout

input_dimensions = X.shape[1]
optimizer = 'rmsprop'
dropout = 0.05
model = Sequential()
inner_nodes = int(input_dimensions / 2)
model.add(Dense(inner_nodes, kernel_initializer='uniform', activation='relu', input_dim=input_dimensions))
model.add(Dropout(rate=dropout))
model.add(Dense(inner_nodes, kernel_initializer='uniform', activation='relu'))
model.add(Dropout(rate=dropout))
model.add(Dense(1, kernel_initializer='uniform', activation='sigmoid'))
model.compile(optimizer=optimizer, loss='mean_absolute_error', metrics=['accuracy'])
model.fit(X, y, batch_size=1, epochs=50)
classifier.save('file_model_name')

Uitleg: Sequential model, input-laag, Dropout tegen overfitting, verborgen lagen, output-laag (1 neurone, sigmoid voor ja/nee), compileren, trainen, opslaan.

Belangrijke parameters: activatiefuncties (relu, sigmoid), kernel_initializer, loss-functie, metrics, optimizer, batch_size, epochs. Alle parameters kunnen/gewenst getund worden voor optimale prestaties.

5. Toekomstige verbeteringen

Weerstation:

• Windsnelheid/richting sensor toevoegen (belangrijk voor model)
• Experimenteren met UV, gas, deeltjes sensoren
• Minimaal twee stations in de zone voor betere gemiddeldes
• Meer jaren data verzamelen (nu 1,5 jaar)

Verwerkingsverbeteringen:

• Data uit andere bronnen integreren (bijv. historische winddata van wunderground.com)
• Keras-model optimaliseren: lagen, neuronen, dropout, metrics, optimizer, loss, batch size, epochs
• Andere architecturen proberen (LSTM gaf iets slechtere resultaten)

Om verschillende parameters te testen:

python train.py --days_behind 600 --test-file-percent 10 --datapoints-behind 6 --hour-granularity 6 --grid-search

Dit zoekt door verschillende batch_size, epoch, optimizer, dropout waarden en print de beste combinatie.

Stap 7: Bonus - Officiële weerdataset gebruiken

Ik wilde weten of een betrouwbaarder weerstation betere resultaten geeft. Ik vond Dark Sky API (https://darksky.net/dev) die historische weergegevens biedt met meer parameters: temperatuur, vochtigheid, druk, windsnelheid, windvlagen, UV-index, zichtbaarheid.

Om mijn bevindingen te repliceren:

1. Download data van Dark Sky of importeer mijn MongoDB-collectie.
   • Account aanmaken, API-key krijgen
   • API-key en geografische coördinaten in download_import/config.py zetten
   • python download_import/darksky.py -d 1000 (gratis API: 1000 requests/dag)
2. Trainen op Dark Sky dataset: python train.py -d 2000 -p 20 -dp 4 -hg 6 --data-source darksky
3. Resultaten bekijken: python predict_batch.py -f sample_data/test_data.csv

Resultaat: algehele voorspellingsnauwkeurigheid steeg van ~80% naar ~90%. Ook de nauwkeurigheid voor alleen regenachtige dagen steeg. Dus: de dataset maakt echt verschil!

Code

Verschillende code-snippets zijn beschikbaar in het originele project (Arduino-sketch, Python-scripts voor training/voorspelling, configuratiebestanden). Zie de GitHub-repository voor complete bestanden.

Schema's

Fritzing-schema beschikbaar: sketch_KAtDa2VReF.fzz

Arduino-sketch voor weerstation: GitHub