Difference between revisions of "Externer Magnetfeldsensor"

Latest revision as of 12:11, 25 March 2024

Magnetfeldern von Permanentmagneten oder stromdurchflossenen Spulen lassen sich mit den in Smartphones integrierten Magnetfeldsensoren praktisch nicht messen. Das liegt daran, dass die eingebauten Sensoren für sehr schwache Magnetfelder ausgelegt sind, um eine Kompassfunktion zu ermöglichen. In der Regel geht der Messbereich bis maximal 5 mT. Möchte man z. B. das Magnetfeld einer Spule entlang der Spulenachse ausmessen, muss der Messbereich eine Größenordnung darüberliegen. Im Folgenden Versuch wird mittels eines Hallsensors (Typ 49e) ein einfach zu benutzender Magnetfeldsensor verwendet, der auch von Oberstufenschülern selbst gebaut werden kann (aktuelle Sicherheitsrichtlinien nach RISU beachten!).

Aufbau
Sensor

Das grüne Kabel unten im Bild ist ein Relikt eines anderen Versuchs und hat hier keine Bewandtnis. Die Platine kann man mit dickem (Kurzschlussgefahr!) dppelseitigen Klebeband aufs ESP-Board kleben. Als Packaging hat sich transparenter Schumpfschlauch bewährt.

Aufbau

Bei B = 0 beträgt die vom Halsensor (49e) ausgegebene Spannung die Hälfte der dort angelegten Spannung. Somit ist die Differenz zwischen Ausgegebener Spannung und halber angelegter Spannung Proportional zum Magnetfeld:

V_out-V_DD∼B.

Die Steigung der Geraden beträgt ca. (3 V)/(200 mT). Die ADCs des ESP32 haben eine Auflösung von 12 Bit. Bei einer anliegenden Spannung U wird somit der Zahlenwert Messwert= U/(3,3 V)⋅4096 herausgegeben. In unserer Schaltung liegt die Ausgangsspannung am Pin 27 des ESP32 an. Dieser gibt den eben erläuterten zur Spannung proportionalen Messwert als Zahl heraus. Die magnetische Feldstärke berechnet sich dann zu

B=(Messwert-4096/2)⋅(200 mT)/4096=(Messwert-2048)⋅0,049 mT.

Da die vorliegende Werte meist etwas driften, wird zu Beginn des Programms wird eine Offsetkorrektur vorgenommen. Das bei Einschalten des Sensors anliegende B-Feld wird als null angenommen. Die Steigung (Faktor 0,049 in Gleichung oben) muss in der Regel individuell an den Sensor angepasst werden. Eine passende Formel findet sich auf dem unten verlinkten Arbeitsblatt. Diese Kalibrierung kann dann mit einer Spule bekannter Geometrie und Windungszahl durchgeführt werden. Beim Programm unten beträgt der Faktor deshalb 0,0492. Zu guter Letzt wird noch eine Mittelwertbildung über 37 Werte vorgenommen. Auch dies lässt sich natürlich individuell anpassen.

V_out geht an Pin 27, + an 3,3 V und – an Gnd. Der Hallsensor wurde hier noch nach oben gebogen, da so z. B. das Magnetfeld einer Spule vermessen werden kann. Um das Rauschen zu verringern, empfiehlt es sich, die Vout-Leitung mit einem 10-kOhm-Widerstand auf Masse zu ziehen.

Das grüne Kabel unten im Bild ist ein Relikt eines anderen Versuchs und hat hier keine Bewandtnis. Die Platine kann man mit dickem (Kurzschlussgefahr!) doppelseitigen Klebeband aufs ESP-Board kleben. Als Packaging hat sich transparenter Schumpfschlauch bewährt.

Programmierung

Der ESP32 wird über die Arduino IDE programmiert. Es müssen die Definitionen für den ESP32 und die phyphox-Bibliothek installiert sein. Siehe dazu das Video unter Category: Arduino library experiments.

Es ist darauf zu achten, dass jeder ESP32 eine eigene Kennung hat (diese wird in PhyphoxBLE::start("Magnetfeldsensor_01") festgelegt). Anschließend kann über das Plus-Symbol in phyphox ein Bluetooth-Experiment hinzugefügt werden, das Experiment wird dann automatisch geladen.

/* ////////////////////////////////////////////////////////////////////////////
  phyphox ESP32 for hall sensor E49
  This program reads out the simple analog values and sends them to phyphox.
  TODO: Calibration option
  AUTHOR: Torsten Klaffs
  LICENSE: CC0
*/

#include <phyphoxBle.h>

// Der Hall Sensor ist verbunden mit GPIO PIN 2
const int hallPin = 27;

// Weitere Defintionen
float hallValue;
float meanHallValue;
float magneticField;
int meanCount = 37;
float offset = 0;

void setup() {
  PhyphoxBLE::start("ESP32 Hall-Sensor 01");       // Bluetooth-Name

  // Defintion des Experimentesa
  PhyphoxBleExperiment e49;
  e49.setTitle("Hall-Sensor");
  e49.setCategory("ESP32 Experiment");

  // Views (Tabs in der App)
  PhyphoxBleExperiment::View firstView;
  firstView.setLabel("Rohdaten");

  // Graph (ein einzelner Graph)
  PhyphoxBleExperiment::Graph firstGraph;
  firstGraph.setLabel("Stärke Magnetfeld");
  firstGraph.setUnitX("s");
  firstGraph.setUnitY("mT");
  firstGraph.setLabelX("Zeit");
  firstGraph.setLabelY("Magnetfeld");
  firstGraph.setChannel(0, 1);

  // Value (zeige Wert, hier den letzten gesendeten)
  PhyphoxBleExperiment::Value firstValue;
  firstValue.setLabel("Magnetfeld");
  firstValue.setUnit("mT");
  firstValue.setPrecision(0);
  firstValue.setChannel(1);

  // Export derDaten
  PhyphoxBleExperiment::ExportSet dataSet;       //Provides exporting the data to excel etc.
  dataSet.setLabel("Data Set");
  PhyphoxBleExperiment::ExportData exportData;
  exportData.setLabel("Data Export");
  exportData.setDatachannel(1);

  // Experiment zusammen stellen
  firstView.addElement(firstGraph);
  firstView.addElement(firstValue);
  e49.addView(firstView);
  dataSet.addElement(exportData);
  e49.addExportSet(dataSet);
  PhyphoxBLE::addExperiment(e49);

  // Offsetkorrektur
  /*
  for(int i=0; i<100; i++) {
    offset += analogRead(hallPin);
    delay(10);
  }
  offset = offset/100;
  */
}

void loop() {
  // Mittelwert über "meanCount" Werte bilden, um Rauschen zu minimieren
  hallValue = 0;
  for (int i = 0; i < meanCount; i++) {
    hallValue = hallValue + analogRead(hallPin);
    delay(5);
  }

  // Genauen Wert ausrechnen
  meanHallValue = (hallValue / meanCount);
  magneticField = (meanHallValue - 2048) * 0.049; //if offset = fixes
  //magneticField = (meanHallValue - offset) * (-0.0492); //if offset korrektion at startup enabled

  // Daten senden
  PhyphoxBLE::write(magneticField);
}

Arbeitsmaterialien

Ein mögliches Schülerarbeitsblatt (aktuelle Sicherheitsrichtlinien nach RISU beachten!) Das folgende Material ist im Rahmen einer Lehrerfortbildung im Jahre 2022 in Niedersachsen entstanden. Es richtet sich an Physiklehrkräfte, also Fachleute. Jede Lehrkraft ist selbst dafür verantwortlich, die aktuell geltenden sicherheitsrichtlinien nach RISU einzuhalten und im Vorfeld selbst eine Gefährdungsbeurteilung zu schreiben. Der Autor dieses Materials übernimmt keinerlei Haftung für Schäden, die bei der Anwendung entstehen.

File:AB Magnetfeldsensor Spule.pdf

@@ Line 1: / Line 1: @@
 {{Infobox Experiment
-  | Name = Entladung eines Kondensators
+  | Name = Externer Magnetfeldsensor
   | Category = Arduino library experiments
-  | Sensors = Voltage
+  | Sensors = 49e
 }}
-In diesem Experiment sollen die Schülerinnen und Schüler die Entladungskurve eines Kondensators messen. Dafür wird der analoge Eingang eines ESP32 (ein günstiger Mikrocontroller) verwendet. Der ESP wird mithilfe der Arduino-Bibliothek so programmiert, dass er die Daten an phyphox übertragen kann.
+Magnetfeldern von Permanentmagneten oder stromdurchflossenen Spulen lassen sich mit den in Smartphones integrierten Magnetfeldsensoren praktisch nicht messen. Das liegt daran, dass die eingebauten Sensoren für sehr schwache Magnetfelder ausgelegt sind, um eine Kompassfunktion zu ermöglichen. In der Regel geht der Messbereich bis maximal 5 mT.
+Möchte man z. B. das Magnetfeld einer Spule entlang der Spulenachse ausmessen, muss der Messbereich eine Größenordnung darüberliegen. Im Folgenden Versuch wird mittels eines Hallsensors (Typ 49e) ein einfach zu benutzender Magnetfeldsensor verwendet, der auch von Oberstufenschülern selbst gebaut werden kann (aktuelle Sicherheitsrichtlinien nach RISU beachten!).
-[[File:SpulenBFeld.jpg|Sensor]]
+<gallery widths=500px heights=300px>
-[[File:B_Sensor.jpg|Sensor]]
+File:SpulenBFeld.jpg|Aufbau
+File:B_Sensor2.jpg|Sensor
+</gallery>
+Das grüne Kabel unten im Bild ist ein Relikt eines anderen Versuchs und hat hier keine Bewandtnis.
+Die Platine kann man mit dickem (Kurzschlussgefahr!) dppelseitigen Klebeband aufs ESP-Board kleben. Als Packaging hat sich transparenter Schumpfschlauch bewährt.
 ==Aufbau==
-Zuerst muss der ESP32 programmiert und verbunden werden. Die Spannung wird zwischen PINXY und GND gemessen.
+Bei B = 0 beträgt die vom Halsensor (49e) ausgegebene Spannung die Hälfte der dort angelegten Spannung. Somit ist die Differenz zwischen Ausgegebener Spannung und halber angelegter Spannung Proportional zum Magnetfeld:
+V_out-V_DD∼B.
+Die Steigung der Geraden beträgt ca. (3 V)/(200 mT). Die ADCs des ESP32 haben eine Auflösung von 12 Bit. Bei einer anliegenden Spannung U wird somit der Zahlenwert Messwert=  U/(3,3 V)⋅4096 herausgegeben.
+In unserer Schaltung liegt die Ausgangsspannung am Pin 27 des ESP32 an. Dieser gibt den eben erläuterten zur Spannung proportionalen Messwert als Zahl heraus. Die magnetische Feldstärke berechnet sich dann zu
+B=(Messwert-4096/2)⋅(200 mT)/4096=(Messwert-2048)⋅0,049 mT.
-''Aufbauanleitung''
+Da die vorliegende Werte meist etwas driften, wird zu Beginn des Programms wird eine Offsetkorrektur vorgenommen. Das bei Einschalten des Sensors anliegende B-Feld wird als null angenommen. Die Steigung (Faktor 0,049 in Gleichung oben) muss in der Regel individuell an den Sensor angepasst werden. Eine passende Formel findet sich auf dem unten verlinkten Arbeitsblatt. Diese Kalibrierung kann dann mit einer Spule bekannter Geometrie und Windungszahl durchgeführt werden. Beim Programm unten beträgt der Faktor deshalb 0,0492.
+Zu guter Letzt wird noch eine Mittelwertbildung über 37 Werte vorgenommen. Auch dies lässt sich natürlich individuell anpassen.
-Anschließend kann direkt losgelegt werden. Die entsprechenden Schaltbilder sind in den Arbeitsblättern zu finden.
+V_out geht an Pin 27, + an 3,3 V und – an Gnd. Der Hallsensor wurde hier noch nach oben gebogen, da so z. B. das Magnetfeld einer Spule vermessen werden kann. Um das Rauschen zu verringern, empfiehlt es sich, die Vout-Leitung mit einem 10-kOhm-Widerstand auf Masse zu ziehen.
+Das grüne Kabel unten im Bild ist ein Relikt eines anderen Versuchs und hat hier keine Bewandtnis.
+Die Platine kann man mit dickem (Kurzschlussgefahr!) doppelseitigen Klebeband aufs ESP-Board kleben. Als Packaging hat sich transparenter Schumpfschlauch bewährt.
 ==Programmierung==
 Der ESP32 wird über die Arduino IDE programmiert. Es müssen die Definitionen für den ESP32 und die phyphox-Bibliothek installiert sein. Siehe dazu das Video unter [[:Category: Arduino library experiments]].
-Es ist darauf zu achten, dass jeder ESP32 eine eigene Kennung hat (diese wird in ''::start(ESP Voltmeter XY)'' festgelegt). Anschließend kann über das Plus-Symbol in phyphox ein Bluetooth-Experiment hinzugefügt werden, das Experiment wird dann automatisch geladen.
+Es ist darauf zu achten, dass jeder ESP32 eine eigene Kennung hat (diese wird in ''PhyphoxBLE::start("Magnetfeldsensor_01")'' festgelegt). Anschließend kann über das Plus-Symbol in phyphox ein Bluetooth-Experiment hinzugefügt werden, das Experiment wird dann automatisch geladen.
 <pre>
+/* ////////////////////////////////////////////////////////////////////////////
+  phyphox ESP32 for hall sensor E49
+  This program reads out the simple analog values and sends them to phyphox.
+  TODO: Calibration option
+  AUTHOR: Torsten Klaffs
+  LICENSE: CC0
+*/
 #include <phyphoxBle.h>
-int ADC_GPIO = 25;    // ESP32
+// Der Hall Sensor ist verbunden mit GPIO PIN 2
-//int ADC_GPIO = A0;  // Arduino Nano 33 BLE
+const int hallPin = 27;
+// Weitere Defintionen
+float hallValue;
+float meanHallValue;
+float magneticField;
+int meanCount = 37;
+float offset = 0;
 void setup() {
+  PhyphoxBLE::start("ESP32 Hall-Sensor 01");       // Bluetooth-Name
+   // Defintion des Experimentesa
-   // put your setup code here, to run once:
+   PhyphoxBleExperiment e49;
-  Serial.begin(115200);
+   e49.setTitle("Hall-Sensor");
-  PhyphoxBLE::start("ESP32 Voltmeter");
+   e49.setCategory("ESP32 Experiment");
-   PhyphoxBleExperiment Voltmeter;
-   Voltmeter.setTitle("Voltmeter");
-   Voltmeter.setCategory("ESP32 Experiments");
-  Voltmeter.setDescription("This experiment will plot the measured voltage over time.");
-   //View
+   // Views (Tabs in der App)
    PhyphoxBleExperiment::View firstView;
-   firstView.setLabel("Data"); //Create a "view"
+   firstView.setLabel("Rohdaten");
-   //Graph
+   // Graph (ein einzelner Graph)
-   PhyphoxBleExperiment::Graph firstGraph;      //Create graph which will plot random numbers over time
+   PhyphoxBleExperiment::Graph firstGraph;
-   firstGraph.setLabel("Voltmeter");
+   firstGraph.setLabel("Stärke Magnetfeld");
    firstGraph.setUnitX("s");
-   firstGraph.setUnitY("V");
+   firstGraph.setUnitY("mT");
-   firstGraph.setLabelX("time");
+   firstGraph.setLabelX("Zeit");
-   firstGraph.setLabelY("Voltage");
+   firstGraph.setLabelY("Magnetfeld");
+  firstGraph.setChannel(0, 1);
+  // Value (zeige Wert, hier den letzten gesendeten)
+  PhyphoxBleExperiment::Value firstValue;
+  firstValue.setLabel("Magnetfeld");
+  firstValue.setUnit("mT");
+  firstValue.setPrecision(0);
+  firstValue.setChannel(1);
-   /* Assign Channels, so which data is plotted on x or y axis
+   // Export derDaten
-     first parameter represents x-axis, second y-axis
+  PhyphoxBleExperiment::ExportSet dataSet;       //Provides exporting the data to excel etc.
-     Channel 0 means a timestamp is created after the BLE package arrives in phyphox
+  dataSet.setLabel("Data Set");
-     Channel 1 to N corresponding to the N-parameter which is written in server.write()
+  PhyphoxBleExperiment::ExportData exportData;
-   */
+  exportData.setLabel("Data Export");
+   exportData.setDatachannel(1);
-   firstGraph.setChannel(0, 1);
+   // Experiment zusammen stellen
+  firstView.addElement(firstGraph);
+  firstView.addElement(firstValue);
+  e49.addView(firstView);
+  dataSet.addElement(exportData);
+  e49.addExportSet(dataSet);
+  PhyphoxBLE::addExperiment(e49);
-   firstView.addElement(firstGraph);            //attach graph to view
+   // Offsetkorrektur
-   Voltmeter.addView(firstView);                //Attach view to experiment
+  /*
-  PhyphoxBLE::addExperiment(Voltmeter);        //Attach experiment to server
+   for(int i=0; i<100; i++) {
+    offset += analogRead(hallPin);
+    delay(10);
+  }
+  offset = offset/100;
+  */
 }
 void loop() {
-   // put your main code here, to run repeatedly:
+   // Mittelwert über "meanCount" Werte bilden, um Rauschen zu minimieren
-   // measures the voltage as fast as possible, then calculates the mean over 100 values
+   hallValue = 0;
-  int meas = 0;
+   for (int i = 0; i < meanCount; i++) {
-   for (int i = 0; i < 100; i++) {
+     hallValue = hallValue + analogRead(hallPin);
-     meas = meas + analogRead(ADC_GPIO);
+    delay(5);
    }
-   meas = meas / 100;
+   // Genauen Wert ausrechnen
+   meanHallValue = (hallValue / meanCount);
-   float meanvoltage = 3.3 * meas / 4095;
+   magneticField = (meanHallValue - 2048) * 0.049; //if offset = fixes
+   //magneticField = (meanHallValue - offset) * (-0.0492); //if offset korrektion at startup enabled
-   //float voltage = 3.3 * analogRead(ADC_GPIO)/4095;
-   //delay(1);
-  PhyphoxBLE::write(meanvoltage);
-  //Serial.print("Voltage = ");
-  Serial.println(meanvoltage);
-   delay(5); // approx 100Hz
+   // Daten senden
+  PhyphoxBLE::write(magneticField);
 }
-/*
-  Over serial with delay(10): approx 100Hz
-  Without delay: much higher
-*/
 </pre>
-==Auswertung==
+==Arbeitsmaterialien==
-Die Unterrichtseinheit gliedert sich in drei Teile: Zuerst wird eine einfache Entladekurve aufgenommen und die Spannung am Kondensator gemessen, dann wird der ''Strom gemessen'' und zuletzt der Spannungsverlauf bei verschiedenen Widerständen gemessen.
+Ein mögliches Schülerarbeitsblatt (aktuelle Sicherheitsrichtlinien nach RISU beachten!)
+Das folgende Material ist im Rahmen einer Lehrerfortbildung im Jahre 2022 in Niedersachsen entstanden. Es richtet sich an Physiklehrkräfte, also Fachleute. Jede Lehrkraft ist selbst dafür verantwortlich, die aktuell geltenden sicherheitsrichtlinien nach RISU einzuhalten und im Vorfeld selbst eine Gefährdungsbeurteilung zu schreiben. Der Autor dieses Materials übernimmt keinerlei Haftung für Schäden, die bei der Anwendung entstehen.
-==Probleme und Lösungen==
-* test
-* test
+[[file:AB_Magnetfeldsensor_Spule.pdf]]
 [[Category:Arduino library experiments]]

Difference between revisions of "Externer Magnetfeldsensor"

Latest revision as of 12:11, 25 March 2024

Aufbau

Programmierung

Arbeitsmaterialien

Navigation menu

Personal tools

Namespaces

Variants

Views

More

Search

Navigation

Tools