Frequentiemeter 1.0

Hoe Bouw Je een Frequentiemeter voor het Elektriciteitsnet met een Arduino

In dit blog deel ik een fascinerend experiment waarin ik een Arduino gebruik om een frequentiemeter te bouwen die de netfrequentie van 50 Hz meet via een standaard wandcontactdoos. Dit project is een geweldige manier om basisprincipes van elektronica en microcontrollerprogrammering te leren en kan eenvoudig worden uitgevoerd met een paar componenten. Hieronder vind je een gedetailleerde beschrijving van hoe dit experiment is uitgevoerd, inclusief uitleg, schema’s en codevoorbeelden.

Het Idee Achter de Frequentiemeter

De netfrequentie (bijvoorbeeld 50 Hz in Europa) is een cruciale parameter in het elektriciteitsnet. Kleine afwijkingen in deze frequentie kunnen belangrijke informatie geven over de belasting van het netwerk. Met een Arduino kun je deze frequentie meten door het analoge signaal van het elektriciteitsnet om te zetten naar een digitaal signaal dat geschikt is voor verwerking door de microcontroller.

Benodigde Componenten

Voor dit experiment heb je de volgende componenten nodig:

Arduino (in dit geval een Arduino Uno R4 WiFi)
230V/15V transformator
Diode (bijv. 1N4007)
Weerstanden voor de spanningsdeler (bijv. 39 kΩ en 10 kΩ)
Transistor (bijv. PN2222A of vergelijkbaar)
Pull-up weerstand (bijv. 10 kΩ)
Kleine experimenteerprint of breadboard
Verbindingsdraden
Multimeter (optioneel, voor debugging)

Schakeling

De schakeling zet het hoge spanningssignaal van de netspanning (230 V AC) veilig om naar een digitaal signaal dat de Arduino kan uitlezen.

Transformator
- Een 230/15V transformator wordt gebruikt om de hoge netspanning te verlagen naar een veiligere waarde van 15V AC.
- Dit verlaagt niet alleen de spanning, maar biedt ook isolatie tussen het net en jouw circuit.
Diodebrug en Spanningsdeler
- Een enkele diode (1N4007) zet de wisselstroom om naar pulsende gelijkstroom. Dit signaal behoudt de frequentie van de netspanning (50 Hz).
- Met een spanningsdeler (bijvoorbeeld 39 kΩ en 10 kΩ weerstanden) wordt de spanning verder verlaagd tot een veilig niveau voor de Arduino (maximaal 5V).
Transistor en Pull-up Weerstand
- De transistor wordt gebruikt om het analoge signaal om te zetten in een digitaal pulssignaal.
- Een pull-up weerstand 10 zorgt ervoor dat het uitgangssignaal stabiel is als de transistor niet geleidt.
Arduino
- Het digitale pulssignaal wordt aangesloten op pin 2 van de Arduino, waar de Arduino gebruik maakt van een interrupt om de frequentie van het signaal te meten.

Het Schakelschema

Hier is een schema van de schakeling

Arduino Code

De Arduino gebruikt een interrupt om de frequentie van het signaal te meten. Hier is een voorbeeldcode voor een Arduino UNO R4 WiFi:

#include <WiFi.h> //bibliotheek om de Wifi verbinding te maken
#include <NTPClient.h> // bibliotheek voor de netwerktijd
#include <WiFiUdp.h> //bibliotheek voor ondersteuning voor communicatie via het UDP-protocol (User Datagram Protocol)

// Constanten
const char* ssid = "Jouw_SSID"; // SSID WIFI Router
const char* password = "Jouw_Password"; //Wifi password
const int signalPin = 2;  // Pin waar het signaal binnenkomt
const float c = 0.9991278; // Correctiefactor/ijken meetapparaat 0,999135
const int numMeasurements = 50;  // Aantal metingen voor het gemiddelde

//Declareren variabelen
volatile unsigned long lastTime = 0;  // Tijd van de laatste interrupt
volatile unsigned long period = 0;    // Tijdsperiode tussen interrupts (in microseconden)
float frequency;  // Variabele om de frequentie op te slaan
float sumFrequency = 0;  // Som van de frequenties
float averageFrequency = 0.0; // Gemiddelde frequentie variabele
int count = 0;  // Tellen van het aantal metingen
unsigned long lastUpdate = 0; // Voor tijdscontrole met millis()

WiFiUDP ntpUDP;
NTPClient timeClient(ntpUDP, "pool.ntp.org", 0, 60000); // NTP-client (UTC)

void setup() {
  Serial.begin(9600);
    
  // Verbinden met WiFi
  connectToWiFi();

  // Start NTP-client
  timeClient.begin();
  
  pinMode(signalPin, INPUT);
  attachInterrupt(digitalPinToInterrupt(signalPin), myinthandler, RISING);
}

void loop() {
  // Update de tijd van de NTP-server
  timeClient.update();
  unsigned long epochTime = timeClient.getEpochTime();

  // Update de frequentie
  if (period > 0) {
    frequency = 1000000.0 / period;  // 1 miljoen omdat we in microseconden werken c = correctie/ijken
    sumFrequency += frequency;
    count++;

    if (count >= numMeasurements) {
      averageFrequency = sumFrequency / numMeasurements * c; // Gemiddelde frequentie
      
  
         
      // Reset frequentiemetingen
      sumFrequency = 0;
      count = 0;
    }

    period = 0;
  }

  // Update de tijd, datum en gemiddelde frequentie elke seconde (controle via millis)
  unsigned long currentMillis = millis();
  if (currentMillis - lastUpdate >= 1000) {
    lastUpdate = currentMillis;
    printDateTime(epochTime);
  }
}

void connectToWiFi() {
  Serial.print("Verbinden met WiFi: ");
  Serial.println(ssid);
  WiFi.begin(ssid, password);
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }
  Serial.println("\nVerbonden met WiFi");
}

bool isLeapYear(int year) {
  return (year % 4 == 0 && (year % 100 != 0 || year % 400 == 0));
}

void printDateTime(unsigned long epochTime) {
  epochTime += 3600; // Aanpassing voor CET (UTC)

  int daysInMonth[] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};

  // Bereken het jaartal
  int year = 1970;
  while (epochTime >= (isLeapYear(year) ? 31622400 : 31536000)) {
    epochTime -= (isLeapYear(year) ? 31622400 : 31536000);
    year++;
  }

  // Controleer op schrikkeljaar
  if (isLeapYear(year)) {
    daysInMonth[1] = 29; // Pas februari aan
  }

  // Bereken de maand
  int month = 0;
  while (epochTime >= daysInMonth[month] * 86400) {
    epochTime -= daysInMonth[month] * 86400;
    month++;
  }
  month += 1; // Maanden zijn 1-gebaseerd

  // Bereken de dag
  int day = epochTime / 86400 + 1;
  epochTime %= 86400;

  // Bereken de uren, minuten en seconden
  int hours = epochTime / 3600;
  epochTime %= 3600;
  int minutes = epochTime / 60;
  int seconds = epochTime % 60;

  // Print de datum, tijd en gemiddelde frequentie naar de seriële monitor
  Serial.print(year);
  Serial.print("-");
  if (month < 10) Serial.print("0");
  Serial.print(month);
  Serial.print("-");
  if (day < 10) Serial.print("0");
  Serial.print(day);
  Serial.print(",");
  if (hours < 10) Serial.print("0");
  Serial.print(hours);
  Serial.print(":");
  if (minutes < 10) Serial.print("0");
  Serial.print(minutes);
  Serial.print(":");
  if (seconds < 10) Serial.print("0");
  Serial.print(seconds);
  Serial.print(",");
  Serial.print(averageFrequency, 3);
  Serial.println("");
}

void myinthandler() {
  unsigned long currentTime = micros();
  period = currentTime - lastTime;
  lastTime = currentTime;
}

Veiligheidstips

Omdat je werkt met netspanning, moet je uiterst voorzichtig zijn:

Zorg ervoor dat de transformator het circuit volledig isoleert van de 230V-lijn.
Controleer dat alle verbindingen stevig zijn en er geen kans is op kortsluiting.
Test het circuit eerst zonder aangesloten netspanning, bij voorkeur met een simulatie of lage testspanning.

Resultaten

Wanneer je het circuit inschakelt en de Arduino code uitvoert:

De Arduino zal pulsen detecteren die corresponderen met de frequentie van het elektriciteitsnet.
Je kunt de frequentie uitlezen via de seriële monitor in de Arduino IDE.

Uitbreidingsmogelijkheden

LCD-scherm toevoegen: Toon de gemeten frequentie op een LCD-scherm.
Data logging: Log de frequentiegegevens naar een SD-kaart of computer.
Netspanningskwaliteit meten: Analyseer kleine afwijkingen in de frequentie en koppel dit aan netwerkbelasting.

Dit experiment biedt een praktische manier om niet alleen elektronica te leren, maar ook inzicht te krijgen in hoe het elektriciteitsnet werkt. Laat me weten of je meer wilt leren over dit project of soortgelijke ideeën hebt!

Er zijn verschillende manieren om de methode voor het meten van de frequentie van het elektriciteitsnet te verbeteren. Overwegingen met betrekking tot filtering, nauwkeurigheid, en algemene prestaties kunnen helpen om het systeem robuuster en betrouwbaarder te maken. Hier zijn enkele belangrijke aspecten en verbeterpunten:

1. Filtering van het Signaal

Een schoon signaal is cruciaal voor nauwkeurige frequentiemetingen.

Huidige Problemen:

Ruis van het netwerk: Elektromagnetische storingen of harmonischen in de netspanning kunnen het signaal vervuilen.
Spikes en Crosstalk: Onzuiverheden in de transformator of ruis van andere elektronische apparaten kunnen verkeerde pulsen veroorzaken.

Verbeteringen:

Laagdoorlaatfilter (RC-filter):
- Gebruik een RC-filter om hoogfrequente ruis te verwijderen voordat het signaal naar de transistor gaat. Kies de afsnijfrequentie net boven 50 Hz.
- Berekening: Kies R=10 kΩ en C=220 nF (fc≈72 {Hz}).
Ontkoppelcondensatoren:
- Plaats condensatoren (0.1 µF en 10 µF) dicht bij de voedingslijnen van de Arduino en de transistor om spanningsfluctuaties te minimaliseren.
Ferrietkralen:
- Voeg ferrietkralen toe op de signaallijnen om hoogfrequente ruis verder te onderdrukken.

2. Nauwkeurigheid van de Frequentiemeting

Het huidige systeem meet pulsen gedurende één seconde. Hoewel dit eenvoudig is, kan het worden verbeterd voor meer precisie.

Verbeteringen:

Verlengde Meetperiode:
- Door over meerdere seconden te meten en een gemiddelde te berekenen, kun je variaties in het signaal verminderen en nauwkeurigere resultaten verkrijgen.
- Bijvoorbeeld: frequentie = pulseCount / meetperiodeInSeconden;
Timer-gebaseerde meting:
- Gebruik een hardwaretimer in plaats van millis() om preciezer de tijd tussen pulsen te meten. Dit is met name nuttig als je microseconden nauwkeurigheid wilt.
- Gebruik de functie micros() om kleinere intervallen te berekenen: unsigned long interval = micros() - vorigePulsTijd; frequentie = 1.0 / (interval / 1000000.0);
Frequentiestandaard:
- Vergelijk de gemeten frequentie met een nauwkeurige referentieklok, zoals een 16 MHz kristal op de Arduino, om afwijkingen te corrigeren.

3. Veiligheid

Het werken met netspanning brengt risico’s met zich mee. Extra beveiligingsmaatregelen kunnen de betrouwbaarheid en veiligheid verbeteren.

Verbeteringen:

Dubbele isolatie:
- Gebruik een dubbel geïsoleerde transformator om de veiligheid te vergroten.
Optocoupler:
- Gebruik een optocoupler in plaats van een transistor om galvanische scheiding te garanderen tussen het net en de Arduino.
Beveiligingscomponenten:
- Voeg een zekering toe aan de primaire kant van de transformator.
- Gebruik overspanningsbeveiliging (bijvoorbeeld een varistor) om schade door stroompieken te voorkomen.

4. Stabiliteit en Ruisonderdrukking

Problemen:

Schommelingen in de voeding kunnen de transistor beïnvloeden, wat resulteert in onbetrouwbare digitale pulsen.

Verbeteringen:

LDO-regulator:
- Gebruik een low-dropout spanningsregelaar om een stabiele voedingsspanning te leveren.
Hysterese:
- Voeg een kleine hysterese toe aan de digitale schakeldrempel om foutieve schakelingen te voorkomen.
- Dit kan worden bereikt door een Schmitt-trigger IC (bijvoorbeeld 74HC14) te gebruiken.

5. Signaalverwerking

De kwaliteit van de frequentiemeting hangt ook af van hoe het signaal wordt verwerkt.

Verbeteringen:

Debouncing:
- Voeg hardwarematig of softwarematig debouncing toe om pieken en storingen in het signaal te elimineren.
Digitale filtering:
- Gebruik software-algoritmen, zoals een moving average, om kleine fluctuaties in de gemeten frequentie te dempen.

6. Bruikbaarheid en Uitbreidingen

Naast nauwkeurigheid zijn er mogelijkheden om de gebruiksvriendelijkheid en functionaliteit te verbeteren.

Verbeteringen:

Weergave:
- Voeg een LCD- of OLED-scherm toe om de gemeten frequentie in realtime weer te geven.
Data logging:
- Log de frequentie naar een SD-kaart of verzend deze via seriële communicatie naar een computer voor verdere analyse.
Alarmering:
- Voeg een alarm toe dat afgaat wanneer de frequentie buiten een gespecificeerd bereik valt (bijvoorbeeld onder 49.5 Hz of boven 50.5 Hz).

7. Analyse van Afwijkingen

Je kunt deze frequentiemeter uitbreiden om schommelingen in het elektriciteitsnetwerk beter te analyseren:

FFT-analyse:
- Gebruik een snelle Fourier-transformatie om harmonischen of onregelmatigheden in de netfrequentie te detecteren.
Jitter-meting:
- Meet hoe stabiel de netfrequentie is over een langere tijd.

Waarom een Arduino Uno R4 WiFi is Gebruikt voor Dit Project

De keuze voor de Arduino Uno R4 WiFi in dit project is strategisch gemaakt vanwege zijn veelzijdigheid en specifieke functionaliteiten die nauw aansluiten bij de behoeften van een frequentiemeterproject. Hier zijn de belangrijkste redenen en voordelen van deze microcontroller:

1. Ingebouwde Real-Time Clock (RTC)

De Arduino Uno R4 WiFi bevat een Real-Time Clock (RTC), wat een belangrijke reden is om deze versie te kiezen. Dit heeft directe voordelen voor dit project:

Tijdstempels voor frequentiemetingen:
- De RTC biedt een nauwkeurige en onafhankelijke tijdbron, waarmee je tijdstempels kunt toevoegen aan elke frequentiemeting. Dit is vooral handig voor data logging of het analyseren van frequentiefluctuaties over tijd.
Geen afhankelijkheid van externe tijdbronnen:
- De ingebouwde RTC elimineert de noodzaak van een externe RTC-module, wat het ontwerp eenvoudiger en compacter maakt.
Automatische tijdsynchronisatie:
- De RTC kan worden gebruikt om metingen te plannen of om statistieken op specifieke tijdstippen te verzamelen.

2. WiFi-connectiviteit voor Netwerktijd

De ingebouwde WiFi-functionaliteit van de Arduino Uno R4 WiFi maakt het mogelijk om verbinding te maken met internet en toegang te krijgen tot een Network Time Protocol (NTP)-server. Dit heeft meerdere voordelen:

Synchronisatie met NTP:
- De Arduino kan zijn RTC synchroniseren met een NTP-server om ervoor te zorgen dat de klok altijd nauwkeurig is. Dit is essentieel in een project dat frequentie-anomalieën of -fluctuaties wil monitoren over een lange periode.
- Dit zorgt ervoor dat de tijdstempels betrouwbaar zijn en nauwkeurig blijven, zelfs na stroomonderbrekingen of herstarten van het systeem.
Remote Monitoring:
- Met WiFi-connectiviteit kun je de gemeten frequentiegegevens naar een server sturen of live weergeven via een webinterface of mobiele app. Dit maakt het project geschikt voor real-time bewaking van het elektriciteitsnet.
Cloud Data Logging:
- De frequentiemetingen kunnen in de cloud worden opgeslagen, wat handig is voor het analyseren van trends en afwijkingen in de netfrequentie over langere tijd.

3. Geavanceerde Functies van de Uno R4 WiFi

Naast de RTC en WiFi biedt de Uno R4 WiFi enkele andere verbeteringen ten opzichte van de traditionele Uno:

Hogere verwerkingssnelheid:
- De R4 heeft een snellere microcontroller (Renesas RA4M1 op 48 MHz), wat zorgt voor nauwkeurigere tijdmetingen en betere verwerking van frequentiesignalen.
Meer geheugen:
- Met 32 kB SRAM en 256 kB Flash-geheugen is er voldoende ruimte voor complexere software, zoals het combineren van RTC-functionaliteit, WiFi-verbindingen en seriële verwerking.

Toepassingen van RTC en WiFi in het Project

Door de combinatie van RTC en WiFi heeft de Arduino Uno R4 WiFi het mogelijk gemaakt om:

Tijdgestuurde metingen te plannen:
- Met behulp van de RTC kun je de frequentie op vaste tijdsintervallen meten en loggen.
Realtime bewaking te bieden:
- De gemeten frequentie kan via WiFi naar een webserver worden verzonden en in real-time worden weergegeven op een dashboard.
Historische data te analyseren:
- Synchronisatie met NTP garandeert dat alle loggegevens correct zijn getime, wat essentieel is bij het analyseren van afwijkingen in het net.
Gebruikersvriendelijke integratie:
- WiFi maakt het eenvoudig om het systeem te integreren met andere IoT-systemen of data-analysetools.