Strahlende Aussichten

Inhaltsverzeichnis

In vergangenen Folgen kam des Öfteren Sensorik im Zusammenhang mit Wetter zur Sprache. Neben Wetterdaten sind aber auch andere Umweltdaten von großem Interesse für unsere Biosphäre.

Das Thema Feinstaub hat der Blog bereits früher adressiert. Die vorliegende Folge beschäftigt sich mit Messung von Radioaktivität.

Umweltsensoren

Nicht erst seit Fukushima wissen wir, dass sich der Einfluss des Menschen auf seine Umwelt nur sehr selten positiv auswirkt. Feinstaub, Kohlendioxid, Schwermetalle oder radioaktive Belastungen haben einen signifikanten und negativen Einfluss auf unsere Gesundheit. Noch heute sind beispielsweise im Voralpengebiet die Auswirkungen der Reaktorkatastrophe von Tschernobyl in Form höherer Strahlenbelastung zu spüren.

Mit der Verfügbarkeit entsprechender Sensoren in Kombination mit Mikrocontroller-Boards lassen sich heutzutage selbstgebaute Messstationen oder sogar weitflächige Sensornetzwerke installieren, die umweltbewusste Bürger von den Angaben anderer Stellen unabhängig machen. Dieser Artikel beschäftigt sich ganz konkret mit Strahlungsmessung.

Radioaktivität

Doch was genau ist eigentlich radioaktive Strahlung? Laut Wikipedia bezeichnet Radioaktivität die Eigenschaft instabiler Atomkerne, spontan ionisierende Strahlung auszusenden. Der Kern wandelt sich dabei unter Aussendung von Teilchen in einen anderen Kern um oder ändert unter Energieabgabe seinen Zustand.

Die beim Zerfallsprozess frei werdende Energie wird entweder als Bewegungsenergie ausgesandter Teilchen (Alpha- oder Beta-Teilchen) oder als Strahlungsenergie in Form von Gammastrahlung abgegeben.

Alpha-Teilchen entstehen beim radioaktiven Zerfall von Atomkernen. Sie bestehen aus zwei Protonen und zwei Neutronen, bilden folglich einen Heliumkern. Zum Abschirmen vor Alpha-Teilchen genügt schon ein Blatt Papier.

Beta-Teilchen existieren in zwei Varianten. Beta⁺-Teilchen sind Positronen, Beta^--Teilchen hingegen Elektronen. Erstere entstehen, wenn sich ein Proton in ein Neutron, ein Positron und ein Neutrino umwandelt. Letztere, sobald Neutronen in Protonen zerfallen, wobei Elektronen und Antineutrinos entstehen. Um sich vor Beta-Teilchen abzuschirmen, ist eine dünnere Metallplatte z.B. aus Aluminium ausreichend.

Gammastrahlung tritt als elektromagnetische Strahlung mit Quantenenergien von über 200 keV auf. Es handelt sich demzufolge um hochenergetische Photonen. Schutz vor Gammastrahlen bieten Schutzwände aus Material mit schwereren Atomkernen. Blei ist ein für diesen Zweck sehr verbreitetes Material.

Die genannten Abschirmmaterialien (Papier für Alpha-Teilchen, Alu für Beta-Teilchen) lassen sich natürlich auch als Filter nutzen, um in einem Messinstrument Alpha-Teilchen oder Beta-Teilchen heraus zu filtern.

Messinstrumente für radioaktive Strahlung

Messinstrumente für radioaktive Alpha-, Beta- oder Gammastrahlung sind im Fachhandel zu erwerben. Entsprechende Produkte mit brauchbarer Qualität gibt es zu Preisen ab 100-150 Euro. Zwar finden sich ebenfalls Angebote für 15 Euro im Handel, die aber den Konsumenten bewusst täuschen, da sie keine Radioaktivität, sondern elektromagnetische Felder messen.

Wesentlich flexibler, zuverlässiger, unterhaltsamer und vor allem lehrreicher ist der Bau eines eigenen Messgeräts. Dass sich hierfür Arduino oder Raspberry Pis als technische Grundlage eignen, wird sich am nachfolgenden Projekt zeigen.

Geiger-Müller-Zählrohr

Wer Radioaktivität messen möchte, kommt um einen sogenannten Geiger-Müller-Zähler nicht umhin, den es in der heutigen Form seit 1928 gibt. Erfunden haben ihn die Physiker Hans Geiger und Walter Müller. Hans Geiger hatte ein paar Jahre für den englischen Physiker Ernest Rutherford gearbeitet, bevor er ab 1912 das Laboratorium für Radioaktivität der Physikalisch-Technischen Reichsanstalt in Berlin leitete. Schon während der Arbeit bei Rutherford hatte der Physiker ein Messinstrument konstruiert, um die ionisierende Wirkung radioaktiver Strahlung anhand elektrischer Messungen nachzuweisen. Leider arbeitete das Zählrohr noch ziemlich unzuverlässig. Zusammen mit Walter Müller entwickelte er deshalb im Jahre 1928 eine stark verbesserte Version des nach ihm benannten Zählrohrs.

Ein Geiger-Müller-Zählrohr besteht aus einem metallischen Zylinder, der ein sogenanntes Zählgas enthält. Dabei handelt es sich meistens um ein Edelgas wie Argon, das unter einen Druck von einigen Bar steht. Durch die Mitte des Zylinders verläuft als Anode ein leitender, nur wenige Mikrometer dicker Draht, zum Beispiel aus Wolfram. Der Metallmantel des Zylinders fungiert als Kathode. An beiden Elektroden liegt eine Spannung von mehreren Hundert Volt an.

Normalerweise besitzen die eingeschlossenen Gasatome keine Ladung. Sobald ein radioaktives Teilchen den Zylinder durchdringt, schlägt es aus Gasatomen Elektronen heraus, die zur Anode wandern. Die entstandenen Gas-Ionen bewegen sich hingegen zum Zylindermantel und nehmen dort jeweils ein neues Elektron auf. Ist die angelegte Spannung genügend hoch, bewirkt jedes freigesetzte Elektron mindestens das Freisetzen eines weiteren Elektrons. Es kommt zur Kettenreaktion in der sogenannten Ionisationskammer. Folge: ein Strom fließt.

Solange sich die meisten Ionen nicht wieder an der Kathode mit einem neuen Elektron versorgt haben, kann das Zählrohr keine neuen radioaktiven Ereignisse zählen. Dieser sehr kurze Zeitraum von rund 100 bis 200 Mikrosekunden heißt dementsprechend Totzeit.

Benötigte Hardware – Zählrohr

Um einen eigenen Geiger-Müller-Zähler zu bauen, ist zunächst einmal ein Geiger-Müller-Zählrohr notwendig. Ein breites Angebot an Zählrohren finden Sie auf der Webseite von GSTube.com, die einen guten Überblick über existierende Zählrohre aller Art vermittelt. Sehr günstig für Preise ab rund 10 bis 15 Euro gibt es das Zählrohr des Typs SBM-20 aus sowjetischen Beständen. Dieses existiert in verschiedenen Varianten (siehe Abbildung). Geben Sie einfach auf eBay das Suchwort "SBM-20" ein, wobei Sie hauptsächlich auf ukrainische Händler treffen.

(Hinweis: Von Dr.-Ing. Karsten Hansky gibt es einen interessanten Vergleich des SBM-20 mit dem russischen Zählrohr SI-39G.)

Für das Projekt in der vorliegenden Folge hat der Autor das SBM-20 in der Originalvariante (zweites Rohr von oben in der Abbildung) verwendet. Der Betrieb des mit Argon, Neon und Brom-Gas gefüllten SBM-20 sollte im Idealfall mit 400 Volt erfolgen. Das sowjetische Datenblatt empfiehlt, einen Widerstand von 5.1 Mega Ohm an der Anode anzubringen. Im Endeffekt bilden Elektroden und das gasgefüllte Rohr einen Kondensator, dessen Kapazität laut Hersteller bei rund 4.2 Pico Farad liegt.

Die Totzeit des rund 10 Gramm leichten, 10 cm langen und rund 1 cm dicken Zählrohrs beträgt dabei rund 190 Mikrosekunden. Es handelt sich übrigens um ein Edelstahlrohr mit 0.05 mm Dicke, das sich demzufolge für die Messung von Beta- und Gammastrahlung, nicht aber von Alpha-Teilchen eignet. Seine Lebenszeit ist mit mindestens 2 x 10¹⁰ Pulsen angegeben.

Benötigte Hardware – Elektronik

Der Eigenbau eines eigenen, vollständigen Geiger-Müller-Zählers ließe sich mit einigem Aufwand realisieren. Allerdings bieten verschiedene Anbieter Boards an, die bereits die notwendige Elektronik mitbringen. Hier nur zwei repräsentative Beispiele:

• SparkFun offeriert ein Board SEN-11345 inklusive Geiger-Müller-Zählrohr auf Basis des ATMega 328 zum Preis von 149 US-Dollar. Da dieses Board den US-Export-Bestimmungen unterliegt, lässt es sich wahrscheinlich nicht ganz ohne Formalitäten erwerben.

• RHelectronics bietet ein Selbstbau-Shield für Arduino zum Preis von 35 US-Dollar ohne Geiger-Müller-Zählrohr an.

Geigerzähler aus M.I.T OpenCourseWare

Das M.I.T OpenCourseWare-Programm offeriert einen Physik-Kurs namens Do It Yourself (DIY) Geiger Counters zum Bau eines Geigerzählers. Das zugehörige PCB-Board ist über Gerber-Dateien beschrieben. Interessierte Maker können sich das Board daher von einem entsprechenden Dienstleistungsunternehmen drucken lassen. Nähere Informationen und detailliertes Kursmaterial zu Geigerzählern im Allgemeinen und zur Hardware im Speziellen findet sich auf der Webseite des Kurses.

Komponenten der Schaltung eines Strahlungsmessgeräts

Zwar lohnt es sich nicht, ein Geiger-Müller-Zähler-Board selbst zu entwickeln. Trotzdem sollten Maker verstehen, welche Komponenten ein solches Board grundsätzlich benötigt.

• Hochspannungstransformator: Das Zählrohr SBM-20 erfordert im Idealfall 400V Arbeitsspannung. Andere Zählrohre kommen sogar weit darüber. Ein Geiger-Müller-Zähler besitzt daher eine Schaltung, um diese hohen geregelten Spannungen zu erreichen.
• Filter und Verstärker: Das Messinstrument muss die gemessenen Signale verstärken und filtern, um auf genaue Ergebnisse zu kommen.
• Strom-Spannungs-Wandler: Durch die Ionisationsvorgänge entstehen Ströme, wohingegen die Schaltung mit spannungsbasierten Signalen arbeitet. Zu diesem Zweck braucht die Hardware eine Schaltungskomponente, die Stromstärken in Spannungen umwandelt.
• Messwertvisualisierung: Um die Strahlung visuell anzuzeigen, enthält das Messgerät meistens eine Leiste aus LEDs, die abhängig von der gemessenen Strahlung "ausschlagen". Zudem dient ein Piezo-Element dazu, die Strahlungsintensität akustisch zu vermitteln.

Arduino-Shield von Libelium bzw. Cooking Hacks

Für das hier vorgestellte Projekt hat der Autor auf ein Arduino-Shield von Cooking Hacks / Libelium zurückgegriffen. Das ist ohne Zählrohr für 79 Euro bei www.cooking-hacks-com verfügbar. Mit dem über eBay erworbenen SBM-20 Zählrohr ergibt sich eine Investition von unter 100 Euro.

Das folgende Fritzing-Diagramm illustriert die Montage eines Zählrohrs an das Shield. Zur stabilen Montage enthält das Shield Bohrungen, über die Sie zum Beispiel das Zählrohr mit Hilfe von Kabelbindern befestigen können.

Insgesamt ergibt sich nach Anbringen des Zählrohrs, in unserem Fall eines SBM-20, folgendes Bild.

Das Shield platzieren Sie huckepack auf Ihren Arduino, zum Beispiel einen Arduino Uno, Leonardo oder Mega. Das Radiation Sensor Board von Cooking Hacks bzw. Libelium löst für jedes erkannte Ereignis einen externen Interrupt am Pin 2 des Arduino-Boards aus (Interrupt 0). Dort erfolgt die Zählung der erkannten Ereignisse pro Minute (cpm). Abhängig vom verwendeten Zählrohr lässt sich dieser Wert in Mikro-Sievert (µSv/h) pro Stunde umrechnen. Beim Verwenden des SBM-20 ist dazu eine Division des Zählers (cpm) durch 360 notwendig. Nutzt der Maker ein anderes Zählrohr, muss er den Konvertierungsfaktor entsprechend adaptieren, idealerweise durch Kalibrierung der Hardware mit Hilfe einer Strahlungsquelle.

Die Ausgabe der Messergebnisse erfolgt in der Regel über das angeschlossene LCD des Libelium-Boards.

Der Code

Der nachfolgende Sketch mit GPL v3 Lizenz stammt von Libelium Comunicaciones Distribuidas S.L. David Gascón ist Urheber des Entwurfs, während Marcos Yarza sich für die Implementierung verantwortlich zeigt.

Der Sketch ist so um deutsche Kommentare erweitert, dass er relativ einfach zu verstehen sein sollte.

Als grober Überblick:

• Im setup() erfolgt die Initialisierung des seriellen Monitors, des LCD-Display, und die Anmeldung der Interrupt Service Routine countPulse().
• countPulse() wird bei abfallender Signalflanke ausgelöst. Das geschieht immer dann, wenn das Radiation Sensor Board ein radioaktives Teilchen erkannt hat.
• Die Methode loop() misst kontinuierlich die Anzahl der Teilchen, rechnet dies auf die Zahl von Ereignissen pro Minute hoch, und mittels Konvertierungsfaktor auch auf µSv/h um. Die Strahlung wird dabei über ledVar() per LEDs visualisiert, am LCD angezeigt, und ebenfalls über den seriellen Monitor gemeldet.
• ledVar(int) schaltet je nach Strahlungsintensität mehr oder weniger LEDs ein beziehungsweise aus.

/////////////////////////////////////////////////////////////////
//
// Arduino-Sketch für einen Geiger-Müller-Zähler auf Basis des
// Geiger Counter - Radiation Sensor Boards bzw. Shields von
// cooking hacks / libelium (c)
// 
/////////////////////////////////////////////////////////////////

// LCD-Bibliothek einbinden:
#include <LiquidCrystal.h>

// Anschluss des LCD an Pins 3,4,5,6,7,8:
LiquidCrystal lcd(3,4,5,6,7,8);


// Schwellwerte für die Visualisierung von Strahlung an den LEDs 
// siehe ledArray:
#define TH1 45
#define TH2 95
#define TH3 200
#define TH4 400
#define TH5 600

// Konvertierungsfaktor um von Teilchen pro Minuten (CPM) 
// auf Micro Sievert per Stunde (uSV/h) umzurechnen:
#define CONV_FACTOR 0.00812

// Variablen:
// Über die LEDs an Pins 10,11,12,13,9 wird die Intensität der Strahlung
// visualisiert:
int ledArray [] = {10,11,12,13,9};

// Radioaktive Teilchen werden dem Arduino über Pin 2 gemeldet:
int geiger_input = 2;

// Zähler auf 0:
long count = 0;
long countPerMinute = 0;
long timePrevious = 0;
long timePreviousMeassure = 0;
long time = 0;
long countPrevious = 0;
float radiationValue = 0.0;

/////////////////////////////////////////////////////////////////////
//
// setup()
//    Initiale Anzeige am LCD
//    Anmelden einer Interrupt Service Routine für fallende
//    Signale am Arduino Pin 2 (geiger_input)
//
/////////////////////////////////////////////////////////////////////

void setup() {
  // Geigerzähler fungiert als Input an Pin 2 (geiger_input):
  pinMode(geiger_input, INPUT);
  // HIGH an geiger_input setzen:
  digitalWrite(geiger_input,HIGH);
  // Alle LEDs als Ausgabepins definieren:
  for (int i=0;i<5;i++){
    pinMode(ledArray[i],OUTPUT);
  }

  Serial.begin(19200); // Serielle Monitor Ausgabe starten

  // Standard LCD am SPI-Bus mit 16 Spalten und 2 Zeilen:
  lcd.begin(16, 2);
  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.print("Strahlungssensor");
  lcd.setCursor(0,1);
  lcd.print("auf dem Arduino");  
  delay(1000);

  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.print(" Cooking Hacks");
  delay(1000);

  lcd.clear();
  lcd.setCursor(0,1);  
  lcd.print("www.cooking-hacks.com");
  delay(500);
  for (int i=0;i<5;i++){
    delay(200);  
    lcd.scrollDisplayLeft();
  }
  delay(500);

  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.print("  - Libelium -");
  lcd.setCursor(0,1);
  lcd.print("www.libelium.com");    
  delay(1000);

  lcd.clear();  
  lcd.setCursor(0, 0);
  lcd.print("CPM=");
  lcd.setCursor(4,0);
  lcd.print(6*count);
  lcd.setCursor(0,1);
  lcd.print(radiationValue);

  // Interrupt 0 für gemessene Strahlung (entspricht
  // Arduino-Pin 2)
  attachInterrupt(0,countPulse,FALLING);
}

/////////////////////////////////////////////////////////////////////
//
// loop()
//    Kontinuierliche Strahlungsmessung
//    Je nach Intensität, Tonausgabe am Piezo-Element
//    und Aktivierung der LEDs
//
/////////////////////////////////////////////////////////////////////

void loop(){
  // Messung auf Minutenbasis hochrechnen, falls 10 Sekunden erreicht:
  if (millis()-timePreviousMeassure > 10000){
    countPerMinute = 6*count;
    // Umrechnung in Micro Sievert pro Stunde:
    radiationValue = countPerMinute * CONV_FACTOR; 
    timePreviousMeassure = millis();
    // Ausgabe der gemessenen Ereignisse pro Minute am seriellen Monitor:
    Serial.print("cpm = "); 
    Serial.print(countPerMinute,DEC);
    Serial.print(" - ");
    // Ausgabe Micro Sievert pro Stunde am seriellen Monitor:
    Serial.print("uSv/h = ");
    Serial.println(radiationValue,4); 
    // Ausgabe am LCD:    
    lcd.clear();    
    lcd.setCursor(0, 0);
    // Ausgabe der gemessenen Ereignisse pro Minute am LCD:
    lcd.print("CPM=");
    lcd.setCursor(4,0);
    lcd.print(countPerMinute);
    lcd.setCursor(0,1);
    // Ausgabe Micro Sievert pro Stunde am LCD:
    lcd.print(radiationValue,4);
    lcd.setCursor(6,1);
    lcd.print(" uSv/h");

    // Abhängig von der festgestellten Strahlung werden die 
    // angeschlossenen LEDs angesteuert. Je intensiver die 
    // Strahlung, desto mehr LEDs leuchten:
    if(countPerMinute <= TH1) ledVar(0); // keine LED leuchtet
    if((countPerMinute <= TH2)&&(countPerMinute>TH1)) ledVar(1);
    if((countPerMinute <= TH3)&&(countPerMinute>TH2)) ledVar(2); 
    if((countPerMinute <= TH4)&&(countPerMinute>TH3)) ledVar(3); 
    if((countPerMinute <= TH5)&&(countPerMinute>TH4)) ledVar(4); 
    if(countPerMinute>TH5) ledVar(5); // => alle LEDs leuchten

    // Zähler auf 0 zurücksetzen:
    count = 0;
  }
}

/////////////////////////////////////////////////////////////////////
//
// countPulse()
//    Hier meldet das Shield festgestellte radioaktive Strahlung 
//    über Pin 2 (geiger_counter)
//
/////////////////////////////////////////////////////////////////////

void countPulse(){
  // Interrupt vorübergehend deaktivieren:
  detachInterrupt(0);
  count++; // Inkrementieren der gezählten Teilchen
  // Warten bis das Shield wieder bereit zum Messen ist:
  while(digitalRead(2)==0){
  }
  // Interrupt erneut aktivieren:
  attachInterrupt(0,countPulse,FALLING);
}

/////////////////////////////////////////////////////////////////////
//
// ledVar(int value)
//    Je nach Wert von <value> werden bis zu 5 LEDs eingeschaltet
//
/////////////////////////////////////////////////////////////////////

void ledVar(int value){
  if (value > 0){
    for(int i=0;i<=value;i++){
      digitalWrite(ledArray[i],HIGH);
    }
    for(int i=5;i>value;i--){
      digitalWrite(ledArray[i],LOW);  
    }
  }
  else {
    for(int i=5;i>=0;i--){
      digitalWrite(ledArray[i],LOW);
    }
  }
}

Betrieb des Geiger-Müller-Zählers

Auf der rechten Seite des Boards gibt es einen Schalter, der das Zählrohr aktiviert. Da am Zählrohr eine relativ hohe Spannung anliegt, bietet es sich aus Sicherheitsgründen an, den Zähler in ein isolierendes Kunststoffgehäuse zu integrieren. Jedenfalls sollten Maker umsichtig agieren und nicht etwa während des Betriebs an die Elektroden des Zählrohrs fassen.

Aktiviert der Maker das Gerät, misst er vor allem Strahlung von wenigen Dutzend Teilchen pro Minute, die überwiegend aus natürlichen irdischen Quellen und dem Weltall stammen. Die Zahl der Sievert pro Stunde (µSv/h) beträgt im Schnitt unter 0.5 µSv/h.

Um höhere Strahlungsdosen zu messen, ist radioaktives Material nötig. Eine Möglichkeit dafür ist der Erwerb von gelbem oder grünem Uranglas, das unter Einfluss von UV-Licht Gammastrahlung erzeugt. Hier eine mögliche Bezugsquelle.

Strahlendosen

Bisher hatte der Artikel zwar die Strahlenmessung über Sievert adressiert, aber nicht näher erläutert, welche Strahlendosen überhaupt harmlos oder welche gefährlich sind.

Laut der Webseite Welt der Physik liegt der natürliche Strahlungshintergrund in Deutschland je nach Region zwischen 0,6 Millisievert pro Jahr (mSv/a) in der norddeutschen Tiefebene und über 1,2 mSv/a in den Mittelgebirgen.

Beim Bundesamt für Strahlungsschutz erhalten Sie unter anderem detaillierte Information über verschiedene Strahlungsdosen und ihre Folgen.

• 0,01 mSv pro Jahr: Rechnerisch ermittelte Größenordnung der jährlichen Höchstdosis der Bevölkerung in Deutschland durch Kernkraftwerke im Normalbetrieb (Diese Berechnungen gehen von konservativen Annahmen unter anderem des Aufenthaltsortes und der Ernährung aus, so dass die tatsächlichen Expositionswerte darunter liegen.)
• bis zu 0,1 mSv: Dosis durch Höhenstrahlung bei einem Flug von München nach Japan
• 2 mSv pro Jahr: Durchschnittliche jährliche Dosis einer Person in Deutschland aus künstlichen Quellen, vornehmlich Medizin (Wert für 2012: etwa 1,9 mSv)
• 10-20 mSv: Dosisbereich für eine Ganzkörper-Computertomographie eines Erwachsenen
• 100 mSv: Bei dieser Dosis treten in einer Bevölkerungsgruppe etwa 1% zusätzliche Krebs- und Leukämiefälle auf
• 1000 mSv: Bei akuter Exposition treten ab dieser Schwellendosis akute Strahleneffekte auf (zum Beispiel Übelkeit, Erbrechen)
• 3000 – 4000 mSv: Ohne medizinische Eingreifen sterben bei dieser Dosis 50 Prozent der exponierten Personen nach 3-6 Wochen, wenn es sich um eine in kurzer Zeit erfahrene Strahlenbelastung handelte (LD50)
• > 8.000 mSv: Ohne entsprechende medizinische Behandlung bestehen nur geringe Überlebenschancen, wenn es sich um eine in kurzer Zeit erfahrene Strahlenbelastung handelte

Zusammenfassung

In dieser Folge haben wir ein Geiger-Müller-Zählers auf Basis des Zählrohrs SBM-20 und des Arduino-Sensor-Shields von Cooking Hacks / Libelium erstellt, nachdem wir uns eingangs mit der physikalischen Funktionsweise eines solchen Messgeräts vertraut gemacht haben.

Wie immer ist das Projekt ausbaufähig. Ein naheliegender Schritt besteht darin, das Ganze über das Internet anzuschließen. Beispielsweise könnten Sie die Messergebnisse auf einer Webseite oder über Tweets publizieren (siehe Beitrag über Gewitterwarner).

Sie könnten freilich auch mit anderen Zählrohren experimentieren.

Auf der Webseite von Cooking Hacks finden sich weitere Anregungen, wie sich der Geiger-Müller-Zähler durch simple Modifikationen erweitern lässt.

Danksagung

Mehr Infos

Mit Fokus auf das Internet of Things - Libelium

Im Beitrag kommt das Strahlungssensor-Board von Libelium zum Einsatz. Genauer gesagt stammt das Board von dessen Maker-Sparte Cooking Hacks. Das junge spanische Unternehmen ist in Saragossa beheimatet, und fokussiert sich seit seiner Gründung vor 10 Jahren auf das Internet der Dinge. Neben Boards für Makers, hat Libelium auch modulare Sensor-Plattformen (Waspmote, Meshlium, Plug & Sense!) und Integrationslösungen für alle Arten von Umweltdatenerfassung im Angebot, die bereits viele namhafte internationale Kunden einsetzen. Libelium beweist, dass smarte Entrepreneurs wie die Firmengründer Alicia Asín (CEO) und David Gascón (CTO) High-Tech-Unternehmen auch in südeuropäischen Ländern erfolgreich gründen und führen können.

An dieser Stelle möchte sich der Autor bei Lara Zapata von der Firma Libelium ganz herzlich für die kostenlose und unbürokratische Bereitstellung eines Arduino-kompatiblen Radiation Sensor Boards bedanken, das dem vorgestellten Projekt als Hardware-Komponente gedient hat.

Mehr Infos

Was bisher geschah:

• Donnerwetter 2.0 – Gewitterwarnungen mit MQTT und Twitter
  
• Auf der Überholspur mit Teensy 3.2
• Die große Arduino Laser Show
• Neues aus der Kreativitätsabteilung
  
• Remote Control
• Von Erleuchtungen und Lichterketten
• Logic Analyzer
• Make your own ESP8266 WiFi Shield
  
• Timer, Counter und Interrupts
• Arduino goes ESP8266
• Bright Side of Arduino
• Genuino bzw. Arduino unplugged
• Arduino-/IoT-Extra – Bibliotheken selbst implementieren
• Kleiner, tiefer, kürzer ... Entwicklung einer Wetterstation
• RESTful mit CoAP
  
• Kommunikation über MQTT
• Nach Hause telefonieren ... mit dem Arduino
  
• Schritt für Schritt
• Anwendungen mit Servo-Motoren
• Gut motorisiert mit Gleichstrommotoren
  
• Arduino für Fledermäuse
• Bewegungserkennung durch Infrarot-Strahlung
  
• Anschluss von LCD-Displays über den IIC-Bus
  
• Lauschen mit Sensoren
  
• JavaScript an Arduino: Es werde Licht
  
• Anschluss vieler LEDs an wenige Ausgänge
  
• Do-it-Yourself-Projekt: iXduino – Arduino on a Breadboard
• Crashkurs "Elektronik für IoT-Anwendungen" (Teil 3 von 3)
• Crashkurs "Elektronik für IoT-Anwendungen" (Teil 2 von 3)
• Crashkurs "Elektronik für IoT-Anwendungen" (Teil 1 von 3)

()