Sensoren

http://sites.prenninger.com/arduino-uno-r3/arduino---sensoren/sensoren

http://www.linksammlung.info/

http://www.schaltungen.at/

                                                                                          Wels, am 2016-11-18

BITTE nützen Sie doch rechts OBEN das Suchfeld  [                                                              ] [ Diese Site durchsuchen]

DIN A3 oder DIN A4 quer ausdrucken
*******************************************************************************I**
DIN A4  ausdrucken
********************************************************I*
015_b_PrennIng-a_arduino.uno.r3-arduino...sensoren-sensoren (xx Seiten)_1a.pdf

918_d_Sensoren-x_Optischen Drehzahlmessung mit Hilfe einer Lochscheibe und Gabellichtschranke_1a.pdf

918_d_Sensoren-x_CNY70 Foto-Reflex-Optokoppler, Infrarot-LED als Sender und IR-FotoTransistor_1a.pdf


~918_d_Sensoren-x_BPW21 Fotodioden gängige Typen § BPW34 BPX48 SFH203_1a.pdf

~918_d_Sensoren-x_BPW40 Fototransistoren gängige Typen § BPW43 BPY62 SFH300_1a.pdf
~918_d_Sensoren-x_LDR03 Fototransistoren gängige Typen § LDR05 LDR07_1a.pdf

~918_d_Sensoren-x_GP1S23 Gabellichtschranke § CNY37 CNY70 TK19732 TCST2000 TCST1103  TCST2103 TCYS5201 TLP621 SFH910_1a.pdf

~918_d_Sensoren-x_NTC-Heißleiter  & PTC-Kaltleiter PT100 PT1000_1a.pdf

CMPS03 Kompass-Modul


                               TUM
                      Technische Universität München

                                    Projekt daedalus

Lehrstuhl für Datenverarbeitung
Prof. Dr.-Ing. Klaus Diepold

Arcisstraße 21
Zentralgelände, Gebäude 9
D-80333 München

918_d_daedalus-x_Meßwerterfassung Praktikumsbericht Datenlogger (20 Seiten)_1a.pdf



01. http://www.daedalus.ei.tum.de/index.php/de/archiv/material/sensoren/stromsensor-ACS712
02. http://www.daedalus.ei.tum.de/index.php/de/archiv/material/sensoren/ultraschallsensor-UST-40
03. http://www.daedalus.ei.tum.de/index.php/de/archiv/material/sensoren/drotek-IMU
04. http://www.daedalus.ei.tum.de/index.php/de/archiv/material/sensoren/ir-abstandssensor   
2Y0A02
05. http://www.daedalus.ei.tum.de/index.php/de/archiv/material/sensoren/ir-thermometer        
MLX90614
06. http://www.daedalus.ei.tum.de/index.php/de/archiv/material/sensoren/gas-sensoren-MQ3-MQ4
07. http://www.daedalus.ei.tum.de/index.php/de/archiv/material/sensoren/ir-sensor-TSOP-31256
08. http://www.daedalus.ei.tum.de/index.php/de/archiv/material/sensoren/ultraschallsensor-SRF02
09. http://www.daedalus.ei.tum.de/index.php/de/archiv/material/sensoren/ultraschallsensor-MB1240
10. http://www.daedalus.ei.tum.de/index.php/de/archiv/material/sensoren/tilt-sensor-RPI-1031

11. http://www.daedalus.ei.tum.de/index.php/de/archiv/material/sensoren/real-time-clock-DS1307
12. http://www.daedalus.ei.tum.de/index.php/de/archiv/material/sensoren/luftfeuchtigkeitssensor-DHT11
13. http://www.daedalus.ei.tum.de/index.php/de/archiv/material/sensoren/luftdrucksensor-BMP085

14. http://www.daedalus.ei.tum.de/index.php/de/archiv/material/sensoren/luftdrucksensor-MS5611
15. http://www.daedalus.ei.tum.de/index.php/de/archiv/material/sensoren/kompass-HMC5883l
16. http://www.daedalus.ei.tum.de/index.php/de/archiv/material/sensoren/lichtsensor-TEMT6000
17. http://www.daedalus.ei.tum.de/index.php/de/archiv/material/sensoren/motion-processing-unit-MPU6050
18. http://www.daedalus.ei.tum.de/index.php/de/archiv/material/sensoren/gyroskop-SD740
19. http://www.daedalus.ei.tum.de/index.php/de/archiv/material/sensoren/beschleunigungssensor-ADXL345


1. Stromsensor   ACS712


Stromsensor(ACS712)

Stromversorgung und Überwachung

1.Stromsensor

Die Sensoren und Mikrocontroller des Zeppelins wurden in den vielen Projekten meist einzeln über einen eigenen Akku versorgt. Dies bedeutete überflüssige Bauteile, ständiges Aufladen der verschiedenen Akkus und keine Kontrolle über die Versorgung. Deshalb bot sich eine Zentralisierung und gleichzeitige Überwachung der Stromversorgung der Komponenten an. Dieser Aufgabe habe ich mich in der folgenden Ingenieurspraxis gestellt.

Im folgenden werden einige zur Anwendung kommende Messarten von Strom gegenübergestellt.



1.1 Stromsensorarten
1.1.1 Stromwandler (AC)
1.1.2 Themische Sensoren
1.1.3 Fiber-optical-current sensor (Faraday-Effekt)
1.1.4 Magnetosresistiver Effekt
1.1.5 Shunt  (Bürdewiderstand / Strommesswiderstand)
1.1.6 Halleffektsensor

 

1.1.1 Stromwandler(passiv)2

Der Stromwandler ist eine Art Transformator der einen Sekundärstrom proportional zum Messstrom erzeugt. Dadurch benötigt er zum einen keine eigene Energiequelle und zum anderen kann er durch eine geeignete Windungswahl einen großen Messbereich bis in den Kiloampere Bereich abdecken. Durch seine Transformatoreigenschaft bedingt kann er aber keinen Gleichstrom messen, was ihn als Strommesser für die Anwendung am Zeppelin ungeeignet macht, da dieser ja durch einen Akku versorgt wir.

1.1.2 Thermische Sensoren

Diese Sensoren nutzen aus, dass abhängig vom Stromfluss und den Materialparametern eine gewisse Leistung in Hitze umgewandelt wird. Veralteten thermische Messgeräte sind Hitzdrahtmesswerke. Aber im Bimetall-Streifen findet sich noch ein gängiges Bauelement, vor allem für Überstromschutzeinrichtungen. Wegen der relativ großen Geräte und Ungenauigkeit bei äußeren Einflüssen im Flugbetrieb ist auch diese Anwendung nicht geeignet.

1.1.3 Faraday-Effekt3

Dieser Effekt nutzt aus, dass die Polarisationsrichtung von Licht durch das Magnetfeld eines Leiters verändert wird. Auch bei sehr hohen magnetischen Feldern erzeugt durch hohe Ströme bis zu 500 Kiloampere erhält man robuste Messungen. Durch das eingesetzte Medium Licht wird der Leiter selbst nicht beeinflusst und es liegt Potentialtrennung vor, die es erlaubt auch bei sehr hohen Spannungen eingesetzt zu werden. Wegen dieser Eigenschaften wir er vor allem in der Energietechnik und zur Messung von Blitzen eingesetzt. Zwar könnte man diesen Sensor auch zur Messung von kleineren Srömen einsetzen, doch da es sich um eine relativ neue Technik handelt und wohl auch nicht in großer Stückzahl hergestellt wird, handelt es sich hier um eine teure Anschaffung im Bereich von 200 bis 300 € pro Stück und entfällt somit ebenfalls für die Anwendung in einem Studentenprojekt.

1.1.4 Magnetoresistiver- Effekt

Hier nutzt man die Veränderlichkeit von Materialen in Abhängigkeit von Magnetfeldern aus. Der Begriff Magnetoresistiver-Effekt umfasst verschiedene atomare Effekte wie den Riesenmagnetowiderstand, der anisotrope magnetoresistive Effekt, planare Halleffekt (nicht mit dem „normalen“ Halleffekt verwechseln) und einigen weiteren Effekten. Als Komponente zur Strommessung lässt er sich sehr kompakt z.B. in ICs verwirklichen. Bei einem Messbereich von 100 Milliampere bis einigen Ampere kann diese Art Sensor nicht in der Strommessung für die Sensoren und Mikrocontroller des Zeppelins eingesetzt werden, da hier Ströme im hundertstel Milliamperebereich auftreten.

1.1.5 Shunt(AC/DC)4

Im Messwiderstand findet man die üblichste Form der Strommessung. Mit einem niederohmigen Widerstand (ca 1mOhm ) kann indirekt über die durch Verstärkerschaltungen erzeugte Spannung der druchfließende Strom gemessen werden. Der Messbereich umfasst so vor allem geringe Ströme, da der Widerstand nicht beliebig hohe Leistungen aushält ( I²·R). Über die Vierleitertechnik kann die Messabweichung der Leitungs-und Anschlusswiderstände kompensiert werden. Schwankende Widerstandseigenschaften (Temparatur, Magnetfeld, etc.) erhöhen Fehlerteufel die Messungenauigkeiten. Zudem muss man zwischen Messung an High oder Low (Masse) unterscheiden, bei denen verschiedene Einschränkungen vorliegen. Wegen des zusätzlichen Widerstandes im Schaltungspfad, der zu unerwünschten Lasteffekten und veränderlichen Messgenauigkeiten führt, schien es mir ratsam eine zuverlässigere Messmethode zu finden.

1.1.6 Halleffektsensor(AC/DC)

Der Halleffekt erzeugt durch Anlegen eines senkrechten Magnetfeldes ein elektrisches Potential im stromduchflossenen Leiter, das proportional abhängig vom Strom ist. Dadurch wird der Stromfluss nur auf vernachlässigbare Weise beeinflusst und bleibt ideal. So hat man freie Wahl an welcher Stelle der Leiter man misst. Einzige Einschränkungen sind externe Magnetfelder. Diese Sensoren ermöglichen Messungen vom Milliamperebereich bis einige Ampere. Aus diesen Gründen und der kompakten den kompakten Bauweisen, erschien mir diese Art der Messung am geeignetsten für meine Anforderumg.



Nun wird die Messung mit dem Sensor näher erläutert.

1.2. Hallsensor ACS712

Grundsätzlich gibt es den ACS712 für verschiedene Strombereiche von peak-to-peak 10A (-5A bis 5A ) bis mindestens 60A mit je einer Versorgungsspannung von 5V. In meinem Aufbau verwende ich den kleinsten Messbereich 10A, wobei bei der Stromversorgung nicht mit so hohen Strömen zu rechnen ist. Das ist dadurch bedingt, dass ich nur die Versorgung für die Sensoren und Mikrokontroller aufbaue, die vielleicht maximal Ströme bis 200 Milliampere(Maximalstrom durch Vcc des Mikrokontrollers) erlauben respektive benötigen. Aber entscheidend für ist nicht der Messbereich sondern die Auflösung des Sensors.

1.2.1 Sensorauflösung5

Im Datenblatt ist von einer Empfindlichkeit (Sensitivity)  von 185mV/A die Rede. Der Stromsenor liefert somit 0,185 Volt pro durchfließendem Ampere. Mit folgender Formel lässt sich daraus der Stromwert errechnen:

 

Abb.1: Ampereberechnung aus Sensordaten6

 

Der Wert 0,0049 begründet sich auf die Leistung des A/D-Wandlers des Arduinos. Mit 10 Bit kann er maximal einen Wert von 1023 bei 5Volt ausgeben. Somit ergibt 5V/1023≈ 0,0049V pro unit die der A/D-Wandler errechnet. Geteilt durch die Sensitivity erhält man dann die Auflösung in Ampere von 0,026 A . Der Rest des Terms bezieht sich auf die Offsetspannung des Sensors. Das heißt bei Nullstrom gibt der Sensor 2,5V Vout an.

Um nun die Auflösung des Sensors zu erhöhen könnte man die Sensitivity mit einer Verstärkerschaltung vergrößern oder einen Wandler mit mehr Bit verwenden.

 

1.2.2 Aufbau

Der ACS712 hat 4 Pins am Eingang und am Ausgang. Zwei Eingangspins werden dabei für einen Stromeingang verwendet. Wohl deswegen, damit bei höheren Strömen die internen Drähte nicht schmelzen. Im Bild sieht man zwar eine Polung des Stroms, doch auch bei verkehrtem Anschluss erhält man eine Ausgabe. Aber diese liegt dann negiert vor!

Abb.2 Sensorpinbelegung

Für das Projekt wurden 4 Sensoren ohne Breakoutboard gekauft. Zur Messung erstellte Fabian Kluger dazu mit der CNC-Fräse von Daedalus eine eigene Platine damit ich mit den Tests starten konnte.

                                                       

a

Sensorplatinenaufbau

Abb.3+4: Sensorplatinenaufbau

 

1.3 Codierung

Zum einen verfasste ich einen .ino Code für den Mikrocontroller

1.3.1 Arduino Stromcontroller-Code (Funktion den Kommentaren entnehmen)

 

#include <SPI.h>

#include <SoftwareSerial.h>

#include <test.h>

 

/************************************************************

* Programm zum Auslesen, Steuern des Stromsensors ACS712 und*

* CAN-Abfrage *

************************************************************/

 

/////////////////GLOBALE VARIABLEN///////////////////////////////////////////////////////////////

 

CANClass CAN;

 

//Datenfeld für den CAN zum senden und empfangen

byte datenfeld_transmit[20];

byte datenfeld_receive[20];

 

//Länge der zu übermittelnden Datenfelder

int laenge_transmit = 11;

int laenge_receive = 11;

 

//Zaehler für Abfrage vom Controller nach einer bestimmten Durchlaufzahl

int CAN_count = 0;

 

//Zaehler für Stromunterbrechung bei fehlender Antwort des Empfängers

int stop_count = 0;

 

//Steuert den einmaligen Reset

int reset = 1;

 

//int zaehler = 0;

 

//AnalogPin zur Strommessung

int an_pin_Sens_1 = 1;

int an_pin_Sens_2 = 2;

 

//Null init

double normierung_Sens_1= 0.0;

double normierung_Sens_2= 0.0;

 

//Stromwert in Ampere

float average_Sens_1 =0.0;

float average_Sens_2=0.0;

 

//DigPin zur Stromsteuerung

int dig_pin_Sens_1 = 3;

int dig_pin_Sens_2 = 5;

 

//Einstellen der erlaubten Ströme in Ampere

int maximal_Strom_Sens_1 = 0.3;

int maximal_Strom_Sens_2 = 0.3;

//////////////////////////////////////////////////////////////////////////////////////////////

void setup() {

 

// CAN-Bus_initialisierung/Adresszuweisung

int adresse_Strom_controller = 0xFF;

CAN.init_adres(adresse_Strom_controller);

 

 

//Mosfetsteuerpins_initialisierung

pinMode(dig_pin_Sens_1,OUTPUT);

pinMode(dig_pin_Sens_2,OUTPUT);

 

digitalWrite(dig_pin_Sens_1, LOW);

digitalWrite(dig_pin_Sens_2, LOW);

 

Serial.begin(9600);

 

//Durch das LOW Schalten oben gilt der folgende Text nicht mehr!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!

/* !!!!: Wenn der Arduino Serial über USB ausliest wird init wird bei jedem Aufruf des Serials (auch über Matlab)

der Ausgabewert auf 0 gelegt, d.h. auch wenn ein Strom schon vorher floss.

Nur die Änderung wird also erkannt.

Das Problem kann durch das Auslesen der Daten über TX/RX (Dig.Pin 1/0) mitHilfe eines "MikroUSB"FDTI-Adapters verhindert werden.

*/

/* Nullsetzen wegen Ungenauigkeit bei Klemmenanschluss(zB. bei Anschluss vom Netzteil zum testen reagiert er

obwohl kein Strom fließt).

*/

//SENSOR 1

for(int i = 0; i < 1000; i++) {

average_Sens_1 = average_Sens_1+(.0264 * (analogRead(an_pin_Sens_1))-13.62);

delay(1);

}

average_Sens_1 = average_Sens_1/1000;

normierung_Sens_1= 13.62+average_Sens_1;

 

//SENSOR 2

for(int i = 0; i < 1000; i++) {

average_Sens_2 = average_Sens_2+(.0264 * (analogRead(an_pin_Sens_2))-13.62);

delay(1);

}

average_Sens_2 = average_Sens_2/1000;

normierung_Sens_2= 13.62+average_Sens_2;

 

//Mathematische Umrechnung siehe Dokumentation zur Sensorauflösung

}

 

void loop() {

 

///////////////////////////////////////CAN////////////////////////////////////

///////////////////////////TRANSMIT///////////////////////////////////////////

if(CAN_count == 10){

 

int empfaenger_adresse_1 = 0xA0;

 

// Serial.print("(Stop_count =");

// Serial.print(stop_count);

// Serial.println(")");

 

Serial.println("Lebscht no?");

 

//für den Übertragungstext "Lebscht no?":

/*Übertragungsdaten*/

 

datenfeld_transmit[0] = 'L';

datenfeld_transmit[1] = 'e';

datenfeld_transmit[2] = 'b';

datenfeld_transmit[3] = 's';

datenfeld_transmit[4] = 'c';

datenfeld_transmit[5] = 'h';

datenfeld_transmit[6] = 't';

datenfeld_transmit[7] = ' ';

datenfeld_transmit[8] = 'n';

datenfeld_transmit[9] = 'o';

datenfeld_transmit[10] = '?';

 

CAN.send(datenfeld_transmit, empfaenger_adresse_1, laenge_transmit);

CAN_count = 0;

stop_count += 1;

 

if(stop_count >3){

Serial.println("Keine Reaktion von Last 1 -> Dauerhaft Abgeschaltet"); //Ausgabe wenn keine Antwort ankommt

}

}

/////////////////////////////////////////////////////////////////////////////////////////////

 

////////////////////////////RECEIVE//////////////////////////////////////////////////////////

CAN.receive(datenfeld_receive, &laenge_receive);

 

//Abfrage ob erlaubte Daten empfangen wurden

if(datenfeld_receive[0] == 'A' && datenfeld_receive[9] == 'r' && stop_count!= 0){ //von "Alles klar!"

/*Ausgabe der empfangenen Daten*/

int i;

 

Serial.print("Antwort von Empfaenger1:");

for(i= 0; i<laenge_receive ; i++){

Serial.print((char)datenfeld_receive[i]);

datenfeld_receive[i]=0; //Zum Buffer löschen

}

Serial.println("");

 

stop_count = 0;

}

/////////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////////////////////////////

////////////////////////////SENSOREN///////////////////////////////////

float average_Sens_1 = 0;

float average_Sens_2 = 0;

 

//SENSOR 1

for(int i = 0; i < 1000; i++) {

average_Sens_1 = average_Sens_1 + (.0264 * (analogRead(an_pin_Sens_1))-normierung_Sens_1);

}

average_Sens_1 = average_Sens_1/1000;

 

//SENSOR 2

for(int i = 0; i < 1000; i++) {

average_Sens_2 = average_Sens_2 + (.0264 * (analogRead(an_pin_Sens_2))-normierung_Sens_2);

}

average_Sens_2= average_Sens_2/1000;

////////////////////////////////////////

// lineares Fehlerverhalten ausgleichen

//SENSOR 1

average_Sens_1 = average_Sens_1+ (average_Sens_1/9);// evtl. noch mindern,aber exakt ab ca 0.5 Ampere

////////////////////////////////////////

////////////////////////////////////////

// lineares Fehlerverhalten ausgleichen

//SENSOR 2

average_Sens_2 = average_Sens_2+ (average_Sens_2/9);// evtl. noch mindern,aber exakt ab ca 0.5 Ampere

////////////////////////////////////////

 

Serial.print(average_Sens_1,4);

// Serial.print('A'); //Bei Auslesen über Matlab "A" kommentieren!

 

Serial.print('\t');

Serial.println(average_Sens_2,4);

// Serial.println('A'); //Bei Auslesen über Matlab "A" kommentieren!

 

/////////////////////////////////////////////////////////////////////////////////////////

//////////////////////////MOSFETSTEUERUNG//////////////////////////////////

 

if (average_Sens_1 < maximal_Strom_Sens_1){

digitalWrite(dig_pin_Sens_1, HIGH);//Test mit LED: Blinken pro loop

}

else{

digitalWrite(dig_pin_Sens_1, LOW);

}

 

// if (zaehler <30){ //Test mit Arduino über zaehler gesteuert

// digitalWrite(dig_pin_Sens_2, HIGH);

// }

 

if(stop_count < 3 && average_Sens_2 < maximal_Strom_Sens_2){

digitalWrite(dig_pin_Sens_2, HIGH);//Test mit Arduino über CAN-Businfo gesteuert

 

if(reset == 2){

reset=3;

}

 

}

else if(stop_count > 2 && reset == 1){

digitalWrite(dig_pin_Sens_2, LOW);//Test mit Arduino

stop_count = 0;

reset += 1;

Serial.println("Keine Reaktion von Last 1 -> Reset");

delay(50);

}

else{

digitalWrite(dig_pin_Sens_2, LOW);

}

 

/////////////////////////////////////////////////////////////////////////////

 

digitalWrite(dig_pin_Sens_1, LOW); //Test mit LED

 

// if(zaehler >= 30){

// digitalWrite(dig_pin_Sens_2, LOW); // Test mit Arduino

// }

//zaehler = zaehler +1;

 

CAN_count = CAN_count +1;

delay(50);

}

}

 

}

else if(stop_count > 2 && reset == 1){

digitalWrite(dig_pin_Sens_2, LOW);//Test mit Arduino

stop_count = 0;

reset += 1;

Serial.println("Keine Reaktion von Last 1 -> Reset");

delay(50);

}

else{

digitalWrite(dig_pin_Sens_2, LOW);

}

/////////////////////////////////////////////////////////////////////////////

 

////////////////////////////SENSOREN///////////////////////////////////

float average_Sens_1 = 0;

float average_Sens_2 = 0;

 

//SENSOR 1

for(int i = 0; i < 1000; i++) {

average_Sens_1 = average_Sens_1 + (.0264 * (analogRead(an_pin_Sens_1))-normierung_Sens_1);

}

average_Sens_1 = average_Sens_1/1000;

 

//SENSOR 2

for(int i = 0; i < 1000; i++) {

average_Sens_2 = average_Sens_2 + (.0264 * (analogRead(an_pin_Sens_2))-normierung_Sens_2);

}

average_Sens_2= average_Sens_2/1000;

 

////////////////////////////////////////

// lineares Fehlerverhalten ausgleichen

//SENSOR 1

average_Sens_1 = average_Sens_1+ (average_Sens_1/9);// evtl. noch mindern,aber exakt ab ca 0.5 Ampere

////////////////////////////////////////

////////////////////////////////////////

// lineares Fehlerverhalten ausgleichen

//SENSOR 2

average_Sens_2 = average_Sens_2+ (average_Sens_2/9);// evtl. noch mindern,aber exakt ab ca 0.5 Ampere

////////////////////////////////////////

 

Serial.print(average_Sens_1,4);

// Serial.print('A'); //Bei Auslesen über Matlab "A" kommentieren!

 

Serial.print('\t');

Serial.println(average_Sens_2,4);

// Serial.println('A'); //Bei Auslesen über Matlab "A" kommentieren!

 

/////////////////////////////////////////////////////////////////////////////////////////

 

digitalWrite(dig_pin_Sens_1, LOW); //Test mit LED

 

// if(zaehler >= 30){

// digitalWrite(dig_pin_Sens_2, LOW); // Test mit Arduino

// }

//zaehler = zaehler +1;

 

CAN_count = CAN_count +1;

delay(50);

}

 




1.3.2. Arduino Last-Code

/*Code für gesteuerten Arduino*/

 

#include <SPI.h>

#include <stdlib.h>

#include <stdio.h>

#include <SoftwareSerial.h>

#include <test.h>

 

CANClass CAN;

 

void setup() {

Serial.begin(9600); //Baudrate einstellen

int adresse_empfaenger_1= 0xA0; //Adresse des Arduinos einstellen (Zweistellig Hexadezimal)

CAN.init_adres(adresse_empfaenger_1); //Adresse übergeben damit Filter gesetzt werden können

}

//Globale Variablen

int adresse_Strom_controller = 0xFF;

 

byte datenfeld_transmit[20];

byte datenfeld_receive[20]; //Datenfeld erstellen um dort die ankommenden Daten zu speichern

 

static int laenge_transmit = 11; //In dieser Variable kann die Länge ausgelesen werden

static int laenge_receive = 11;

 

int gesendet=0;

int empfangen = 0;

 

void loop(){

 

CAN.receive(datenfeld_receive, &laenge_receive); //Befehl zum Empfange, dafür ist nötig das Datenfeld und die Variable,

 

//Nachrichtenauswertung

if(datenfeld_receive[0] == 'L'){ //L von Lebscht no?

 

empfangen == 1;

Serial.print("Controller fraegt: ");

int i;

for(i=0; i<laenge_receive ;i++){ //Ausgabe des Datenfeldes

Serial.print((char)datenfeld_receive[i]);

}

Serial.println("");

//Text: "Alles klar!"

/*Übertragungsdaten*/

datenfeld_transmit[0] = 'A';

datenfeld_transmit[1] = 'l';

datenfeld_transmit[2] = 'l';

datenfeld_transmit[3] = 'e';

datenfeld_transmit[4] = 's';

datenfeld_transmit[5] = ' ';

datenfeld_transmit[6] = 'k';

datenfeld_transmit[7] = 'l';

datenfeld_transmit[8] = 'a';

datenfeld_transmit[9] = 'r';

datenfeld_transmit[10] = '!';

 

CAN.send(datenfeld_transmit, adresse_Strom_controller ,laenge_transmit);

gesendet = 1;

Serial.println(" ");

}

else{

Serial.println("Keine Anfrage erhalten!");

Serial.println(" ");

empfangen == 0;

gesendet == 0;

}

//delay der den restlichen Code simuliert

delay(500);

}



2. Stromversorgung

Da nun der Überblick und die Codierung für die Sensoren abgeschlossen war, galt es die Stromversorgung anzugehen. Die grundsätzliche Überlegung war es für den Zeppelinflug eine mobile und überwachte Stromversorgungseinheit zu entwickeln.

2.1. Schaltplan

Zur Verfügung stand ein Akku mit 14,8V der auf die für die Sensoren und Mikrocontroller nötigen Spannungen von 5V und 3,3V herunter geregelt werden musste. Die einzelnen Lasten sollten dann über je einen Stromsensor versorgt werden. Zudem zeigt eine LED an, ob Strom fließt. Die Steuerung übernehmen MOSFETs da ein Transistor mit seinem Durchbruchstrom die Messung verfälschen könnte. Insgesamt stehen in dem von mir erstellten Schaltplan vier Anschlüsse für 3,3V-Lasten und zwei für 5V zur Verfügung. Pinbelegungen sind dem Schaltplan und dem Arduinocode zu entnehmen.

 Schaltplan der Stromversorgung mit Stromsensor

Abb.5 Schaltplan der Stromversorgung mit Stromsensor (Eagle)

 

2.2. Steuerung

Wie im Code zu erkennen ist gibt es zwei Steuerprinzipien der Stromversorgung.

2.2.1. Sensorsteuerung

Fast jedes Bauteil von Mikorkontrollern bis zu LEDs braucht einen gewissen Strom und erlaubt auch nur einen gewissen Maximalwert. Darüber hinaus geht das Bauteil kaputt. Mit Hilfe des Stromsensors lässt sich nun messen wie groß der Wert ist der von den Lasten gezogen wird. Will man verhindern, dass ein zu großer Strom zu lange fließt kann man über die Variablen „maximal_Strom_Sens_NummerdesSensors“ diesen Wert festlegen und der Steuermikrocontroller schaltet den MOSFET, damit die Versorgung unterbrochen wird. 

 

Abb.6 Strommessung einer LED (links) und gesteuerte Strommessung eines Arduinos (rechts)

2.2.2. CAN-Steuerung

Zunächst muss dem Mikrocontroller der als Last wirkt der Code aus dem Programm „CAN_Strom_receiver“ in der Schleife hinizugefügt werden.Benutzt wird hierbei zur CANduino Bibliothek  die CANdalus7- Erweiterung, welche in einem parallelem Praktikum angefertigt wurde.

Unter Ausnutzung der CAN-Bus Kommunikation wird dann überprüft ob der versorgte Mikrocontroller ordnungsgemäß seine Schleifen durchläuft und so auch auf Anfragen über den CAN-Bus antwortet. Sollte sich der Mikrocontroller in einer Endlosschleife gefangen haben oder anderweitig seine Funktion nicht mehr erfüllen, findet keine Kommunikation mehr zwischen den Controllern statt. Dies wird erkannt und ein Reset in Form von zweimaligem Schalten des zuständigen MOSFETS wird durchgeführt. Sollte diese Maßnahme zu keiner Besserung führen wird nach einer gewissen Wartezeit die Stromzufuhr entgültig gekappt.

 

Quellen:

1 de.wikipedia.org/wiki/Stromsensor

2 http://www.mikrocontroller.net/articles/Stromwandler

3 Siehe Anhang 1 und Anhang 2

4 http://www.elektroniknet.de/messen-testen/sonstiges/artikel/84373/

5 http://www.lionprecision.com/tech-library/technotes/article-0010-sensor-resolution.html oder http://arduino.cc/forum/index.php?PHPSESSID=2095ab88c80f3acc104d57c2c333e127&topic=127917.0

6 http://www.lucadentella.it/en/2011/11/29/sensore-di-corrente-con-arduino/

http://www.daedalus.ei.tum.de/index.php/de/dokumentation/projekte/komm-struktur/candalus

 

Anhänge:
Diese Datei herunterladen (FiberOpticCurrentSens.pdf) Anhang1: FiberOpticalCurrentSens[ ]
Diese Datei herunterladen (SENSOR_CONF_fiber_optic_current_sensor.pdf)Anhang2: SENSOR_CONF_fiber_optic_current_sensor[ ]


http://www.daedalus.ei.tum.de/index.php/de/archiv/material/sensoren/stromsensor-acs712







2. Ultraschallsensor  UST-40

Die UST-40R (Empfänger) und UST-40T (Sender) sind Ultraschallempfäger- bzw. Sender ohne jeglichen Mikrochip oder Messeinrichtung und bieten somit eine große Flexibilität. Die UST-40 arbeiten bei einer Frequenz von 40kHz ±1  und bei einer maximalen Spannung von 20V.

Für einen Sendeimpuls eignet sich ein Rechtecksimpuls mit acht Impulsen und einer Periodendauer von 25µs und einer Pulsdauer von 12.5µs (Dutycycle 50%)

Air Ultrasonic Ceramic  Transducers  400ST160 Transmitter   400SR160 Receiver
https://cdn-reichelt.de/documents/datenblatt/B400/UST%23PRT.pdf
http://www.daedalus.ei.tum.de/index.php/de/archiv/material/sensoren/ultraschallsensor-ust-40







3. Drotek-IMU 10DOF

Drotek-IMU

IMU 10DOF - MPU6050 gyro & accelerometer + HMC5983 magnetometer + MS5611 altimeter   Ref.: CAP0062Z02


IMU mit 3-Achsen Gyro/Beschl./Magnetfeld-Sensor + Luftdruck (+ Temperatur)

Hersteller:
# Sensorboard auslesen http://wiki.daedalus.ei.tum.de/tiki-index.php?page=Sensorboard+auslesen ###

http://www.drotek.fr/shop/en/home/62-imu-10dof-mpu6050-hmc5883-ms5611.html

Sensorboard auslesen
http://wiki.daedalus.ei.tum.de/tiki-index.php?page=Sensorboard+auslesen

http://www.daedalus.ei.tum.de/index.php/de/archiv/material/sensoren/drotek-imu







4. IR-Abstandssensoren von SHARP 2Y0A21

SHARP
2Y0A21
                 http://www.daedalus.ei.tum.de/attachments/article/70/SHARP_2Y0A02.pdf
SHARP 2Y0A02              http://www.daedalus.ei.tum.de/attachments/article/70/SHARP_2Y0A21.pdf

Aufbau:
Sender und Empfänger in einem Bauteil, jeweils durch eine Linse fokussiert
-Plastikgehäuse, durch zwei Löcher montierbar
-3-polige Anschlussbuchse

Funktionsweise:
Der Sender strahlt einen durch die Linse stark gebündelten IR-Strahl aus, der vom Hindernis reflektiert wird.
Die Detektion der Entfernung erfolgt mittels Triangulation (Je weiter entfernt das Hindernis, desto kleiner der Winkel zwischen emittierten und reflektierten Lichtstrahl).
Anstelle einer üblichen Photodiode enhalten die SHARP-Sensoren ein PSD ("Position Sensitive Device", quasi eine "langgezogene" Photodiode):
Je nachdem, an welcher Stelle der empfangene Lichtstrahl auf die Photofläche trifft, teilt sich der Fotostrom entsprechend der Position des Punktes in zwei Teile.
Aus dem Quotienten von Differenz und Summe der beiden Ströme erhält man ein von der Lichtleistung unabhängiges Positionssignal

Vorteile:
-Leicht zu verwenden (Anschluss kann direkt an einen AD-Wandler eines Microcontrollers erfolgen)
-Messungen relativ unabhängig von Beschaffenheit und Farbe der reflektierenden Oberfläche

Probleme:
-Jede Messung dauert um die 50ms →ziemlich reaktionsträge (Verwendung z.B. zur automatischen Toilettenspülung)
-nicht wenige "Ausreißer" in den detektierten Entfernungswerten, weshalb sich eine Mehrfach-messung mit Anullierung des höchsten
und niedrigsten gemessenen Wertes und einer anschließenden Mittelung empfiehlt
-Nichtlinearer Zusammenhang zwischen Ausgangssignal und gemessener Entfernung.
Abhilfe durch Skalierung der dem Sensor entnommenen Werten oder durch Linearisierung des relevanten Messbereichs
http://www.daedalus.ei.tum.de/index.php/de/archiv/material/sensoren/ir-abstandssensor





5. IR-Thermometer MLX90614


Infrarot Thermometer - MLX90614  IR-Thermometer




http://www.watterott.com/de/Infrared-Thermometer-MLX90614

In der Lage zu spüren Temperatur ist cool ... aber in der Lage, die Temperatur eines Objekts, ohne auch nur zu berühren lesen ist einfach genial.

Der MLX90614 ist ein Sensor, genau das tun.
Durch das Lesen der Infrarot-Licht ein Objekt kommen aus, kann dieser Typ zwischen -95 und 720ºf (-70 bis 382,2 ° C) mit 17 Bit Auflösung erfassen.

Das ist 128X präziser als der Arduino ADC und bedeutet dieser kleine Kerl kann den Unterschied zwischen 25 ° C und 25.02ºC ohne auch nur in Berührung kommen, zu erzählen. (Mit 17 Bit aufgeteilt zwischen -70 und 382 sollten uns 0.0034ºC Auflösung zu geben).

Ich habe mein Auge auf dieser Kerl hatte, seit ich sah es an Sparkfun, aber nie einen Grund, um eins zu bekommen hatte.
Dann schaut sich um, schien der MLX90614 zu sein, die einige Leute eine harte Zeit, wenn sie versuchen, es zu ihrem Arduino verbinden.
So ... wir Bildr getan, was wir am besten können, kauften wir ein und dauerte einige Zeit, Ihr Leben einfacher zu machen und diese läuft.

Dies ist ein I2C-Gerät wie viele Sensoren wir zuvor gesprochen haben, aber im Gegensatz zu all den I2C-Sensoren haben wir zu vorher geschrieben wurde, kann der MLX90614 nicht mit dem Draht-Bibliothek, um mit ihm zu kommunizieren, so werden wir mit einer anderen Bibliothek, auch , im Gegensatz zu, was wir in der Regel behandeln, ist die MLX90614 nicht auf einem Breakout-Board, so dass es erfordert einige Pull-up-Widerstände auf beiden Daten- und Taktleitungen (In der Regel werden diese auf der Platine enthalten, wir haben einfach nicht bemerkt. )

Die Standard-Draht-Bibliothek wurde nicht für die Menschen, so dass wir, statt, mit dem i2cmaster Bibliothek.

Um die Sache noch komplizierter zu machen, die i2cmaster gewohnt auf dem Arduino laufen out of the box, müssen einige Dateien umbenannt und geändert werden kann, und ein extra txt-Datei ist erforderlich, das gehen solle.

Aber ..., weil es Open-Source ich diese Änderungen vornehmen, und weitergeben.
Also das ist, was ich tun werde, werde ich dir nur die ihm hier in seiner Arbeits Version, die Sie sich etwas Zeit und Kopfschmerzen zu speichern.
Sie müssen die Bibliothek in Ihr Arduino Library-Ordner fallen, damit es funktioniert, aber wir werden es schaffen.
Wie für den Anschluss dieses oben, auf dem Arduino (alles außer dem Mega) SDA ist am Analogeingang Pin 4 und SCL ist auf analoge Pin 5.
Auf einem Arduino Mega ist SDA digitale 20 und SCL ist digital 21. Blick auf die Bild zu sehen, wie es angeschlossen werden soll, sondern ein 4.7KΩ Widerstand muss von SDA bis 3,3 V angeschlossen werden, und eine weitere von SCL nach 3,3V.
Ich habe auch eine .1uf Kondensator zwischen Strom und Masse als im Datenblatt angegeben ist, aber ich habe gesehen, andere nicht verwenden, und ich habe es ohne getestet und es funktionierte noch.

Code
So, hier ist der Code.

Denn es besteht aus vielen Dateien, verwende ich Lust bildrCode Wrapper Bildr ist.
Dies erlaubt uns, dem Wiki, wie die Kontrolle über viele Dateien für ein einzelnes Projekt haben - genau wie dieser.
All dieser Code tut, ist Ausgangs die Temperatur sowohl in Celsius und Fahrenheit über serielle. So öffnen Sie die Serien Monitor!
Um diesen Code funktioniert, bevor Sie den Code der Arduino Programm zu laden oder auch nur zu öffnen, müssen wir die "I2Cmaster" in Ihrem Arduino Bibliothek legen. Wenn Sie nicht wissen, wo das ist standardmäßig Schau nach rechts.
Sobald die I2CMaster Ordner ist in dort können Sie einfach weitermachen und offene MLX90614.pde in Ihrem Arduino-Software, und laden Sie sie.

http://bildr.org/2011/02/mlx90614-arduino/


#include <LiquidCrystal.h>
#include <i2cmaster.h>
 
 
LiquidCrystal lcd(12, 11, 5, 4, 3, 2);
 
void setup() {
  lcd.begin(16, 2);
  lcd.print("Daedalus");
  delay(1000);
  i2c_init(); //Initialise the i2c bus
  PORTC = (1 << PORTC4) | (1 << PORTC5);//enable pullups
}
 
 
void loop(){
    int dev = 0x5A<<1;
    int data_low = 0;
    int data_high = 0;
    int pec = 0;
     
    i2c_start_wait(dev+I2C_WRITE);
    i2c_write(0x07);
     
    // read
    i2c_rep_start(dev+I2C_READ);
    data_low = i2c_readAck(); //Read 1 byte and then send ack
    data_high = i2c_readAck(); //Read 1 byte and then send ack
    pec = i2c_readNak();
    i2c_stop();
     
    //This converts high and low bytes together and processes temperature, MSB is a error bit and is ignored for temps
    double tempFactor = 0.02; // 0.02 degrees per LSB (measurement resolution of the MLX90614)
    double tempData = 0x0000; // zero out the data
    int frac; // data past the decimal point
     
    // This masks off the error bit of the high byte, then moves it left 8 bits and adds the low byte.
    tempData = (double)(((data_high & 0x007F) << 8) + data_low);
    tempData = (tempData * tempFactor)-0.01;
     
    float celcius = tempData - 273.15;
 //   float fahrenheit = (celcius*1.8) + 32;
    lcd.clear();
    lcd.print("Celcius: ");
    lcd.print(celcius);
     
    delay(200);
     
}

http://www.daedalus.ei.tum.de/index.php/de/archiv/material/sensoren/ir-thermometer






6. Gas-Sensoren MQ3 / MQ4

Gas-Sensoren MQ3 / MQ4

Alkohol-Sensor MQ-3

Methan-Sensor MQ-4.

Ansteuerung:

5V Heizspannung Anlegen (~150mA) und zwischen zwei anderen Pins den Widerstand messen. (siehe Datenblatt)


Alkohol-Sensor (extern)
Methan-Sensor (extern)

Versuche:

Alkohol-Sensor:
Lastwiderstand: 20k
Spannung nach ca. 10 min Heizen: ~0,8-1V
Spannung mit Flasche Bier: ~4V
Spannung mit Flasche Mineralwasser (CO2): ~1V

Methan-Sensor:
Lastwiderstand: 20k
Spannung nach ca. 10 min Heizen: ~1,9-2V
Spannung mit Gasfeuerzeug: 5V
Anhauchen: 3,1V

Noch ein Gassensor mit Platine für Wasserstoff:

http://www.dfrobot.com/index.php?route=product/product&filter_name=dfr0049&product_id=88


http://www.daedalus.ei.tum.de/index.php/de/archiv/material/sensoren/gas-sensoren-mq3-mq4







7. IR Sensor  TSOP 31256

IR Sensor (TSOP 31256)

http://www.daedalus.ei.tum.de/attachments/article/67/A500-TSOP312SERIES_DATASHEET-1.pdf
http://www.daedalus.ei.tum.de/attachments/article/67/A500-TSOP312SERIES_DATASHEET-1.pdf





Ultraschallsensor (SRF02)


Quelle:
www.robot-electronics.co.uk/htm/srf02tech.htm

Die Kommunikation mit dem SRF02 erfolt über Serielle Schnittstelle oder I²C.
Die folgenden Beispielprogramme werden ausschließlich im I²C Modus vorgestellt.

Das Befehlsregister, mit dem die verschiedenen Befehle ausgeführt werden können, ist das Register 0.
Um einen Befehl auszuführen muss lediglich der enstsprechende Befehlscode in das Register geschrieben werden.

//ground
#include <SoftwareSerial.h>
#include <Wire.h>
 
//----------config starts here-----------
const boolean useI2c = true; //srf02 mit i2c oder uart
const byte temperature =  21;      //temperature in Celsius
//const byte receiverAddress = 2; //uart = i2c - 112;
const byte receiverAddress = 114; //i2c = uart + 112
//----------config ends here-------------
 
const float speedOfSound =  0.0200457 * sqrt(temperature + 273.15);      //speed of sound mm/µs
unsigned int receiverReading = 0;
SoftwareSerial srf02(10, 11); // RX, TX
 
void setup()
{
  Wire.begin();
  srf02.begin(9600);
  Serial.begin(9600);          // start serial communication at 9600bps
  Serial.println("Start");
  /* Set address to E0
  int newAddress = 224;
  for (int i=0;i<16;i++) {
    oldAddress = 112 +i;
    changeAddress(byte(oldAddress), byte(newAddress));
  }
  */
}
 
 
void loop()
{
  int reading = 0;
  if (useI2c) {
    i2cStartMeasurement(byte(receiverAddress));
  } else {
    uartStartMeasurement(byte(receiverAddress));
    srf02.listen();
  }
  delay(70);    // datasheet suggests at least 65 milliseconds
  if (useI2c) {
    receiverReading = i2cGetMeasurement(byte(receiverAddress));
  } else {
    receiverReading = uartGetMeasurement(byte(receiverAddress));
  }
  Serial.print(receiverReading);
  Serial.print("\t|\t");
  receiverReading = receiverReading * speedOfSound;
  Serial.println(receiverReading);
  delay(200);
}
 
int uartGetMeasurement (byte address) {
  int reading = -1;
  srf02.write(address);
  srf02.write(0x5E);      // Get Range, returns two bytes (high byte first) from the most recent ranging.
  while (srf02.available() < 2);
  if (srf02.available() > 0) {
    reading = srf02.read();
  }
  reading = reading << 8;
  //while (srf02.available() == 0);
  if (srf02.available() > 0) {
    reading |= srf02.read();
  }
  return reading;
}
 
void uartStartMeasurement (byte address) {
  //address = (address >> 1) & 0x0F;
  srf02.write(address);
  srf02.write(0x52);
}
 
 
 
int i2cGetMeasurement (byte address) {
  int reading = -1;
  Wire.beginTransmission(address);     // transmit to device #112
  Wire.write(byte(0x02));              // sets register pointer to echo #1 register (0x02)
  Wire.endTransmission();              // stop transmitting
  Wire.requestFrom(address, byte(2));  // request 2 bytes from slave device #112
  if(2 <= Wire.available())            // if two bytes were received
  {
    reading = Wire.read();             // receive high byte (overwrites previous reading)
    reading = reading << 8;            // shift high byte to be high 8 bits
    reading |= Wire.read();            // receive low byte as lower 8 bits
  }
  return reading;
}
 
void i2cStartMeasurement (byte address) {
    Wire.beginTransmission(address);
    Wire.write(byte(0x00));
    Wire.write(byte(0x52));
    Wire.endTransmission();
}
 
void i2cFakeRange (byte address) {
    Wire.beginTransmission(address);
    Wire.write(byte(0x00));
    Wire.write(byte(0x5C));  //0x50  Real Ranging Mode - Result in inches
                             //0x51  Real Ranging Mode - Result in centimeters
                             //0x52  Real Ranging Mode - Result in micro-seconds
                             //0x56  Fake Ranging Mode - Result in inches
                             //0x57  Fake Ranging Mode - Result in centimeters
                             //0x58  Fake Ranging Mode - Result in micro-seconds
                             //0x5C  Transmit an 8 cycle 40khz burst
    Wire.endTransmission();
}
void i2cChangeAddress(byte oldAddress, byte newAddress)
{
// !! newAddress =  {224-239}
  Wire.beginTransmission(oldAddress);
  Wire.write(byte(0x00));
  Wire.write(byte(0xA0));
  Wire.endTransmission();
 
  Wire.beginTransmission(oldAddress);
  Wire.write(byte(0x00));
  Wire.write(byte(0xAA));
  Wire.endTransmission();
 
  Wire.beginTransmission(oldAddress);
  Wire.write(byte(0x00));
  Wire.write(byte(0xA5));
  Wire.endTransmission();
 
  Wire.beginTransmission(oldAddress);
  Wire.write(byte(0x00));
  Wire.write(newAddress);
  Wire.endTransmission();
}

http://www.daedalus.ei.tum.de/attachments/article/66/Ultrasonic%20Sensor%20Operation%20on%20a%20Quadcopter.pdf
http://www.daedalus.ei.tum.de/index.php/de/archiv/material/sensoren/ir-sensor-tsop-31256







8. Ultraschallsensor  SRF02

Der Ultraschallsensor SRF02 dient zur Längenmessung über die Laufzeit des Ultraschalls. Dafür gibt es generell zwei verschiedene Modi:

  • Messung der Distanz/Laufzeit über Reflexion an einem Gegenstand (hierfür wird nur ein SRF02 benötigt)
  • Messung der Distanz/Laufzeit über eine Sender-Empfängerstrecke (hierfür werden selbstverständlich zwei (oder mehr) SRF02 benötigt

Es können jeweils entweder Laufzeiten (in µs) oder Distanzen (in cm oder inch) ausgelesen werden.
Die verschiedenen Modi können auch entsprechend der folgenden Tabelle entnommen werden.

Command (Hex) Action
0x50 Real Ranging Mode - Result in inches
0x51 Real Ranging Mode - Result in centimeters
0x52 Real Ranging Mode - Result in micro-seconds
0x53 Real Ranging Mode - Result in inches, automatically Tx range back to controller as soon as ranging is complete
0x54 Real Ranging Mode - Result in centimeters, automatically Tx range back to controller as soon as ranging is complete.
0x55 Real Ranging Mode - Result in micro-seconds, automatically Tx range back to controller as soon as ranging is complete
   
0x56 Fake Ranging Mode - Result in inches
0x57 Fake Ranging Mode - Result in centimeters
0x58 Fake Ranging Mode - Result in micro-seconds
0x59 Fake Ranging Mode - Result in inches, automatically Tx range back to controller as soon as ranging is complete
0x5A Fake Ranging Mode - Result in centimeters, automatically Tx range back to controller as soon as ranging is complete
0x5B Fake Ranging Mode - Result in micro-seconds, automatically Tx range back to controller as soon as ranging is complete
   
0x5C Transmit an 8 cycle 40khz burst - no ranging takes place
0x5D Get software version - sends a single byte back to the controller
0x5E Get Range, returns two bytes (high byte first) from the most recent ranging
0x5F Get Minimum, returns two bytes (high byte first) of the closest range measurable - see Autotune section
0x60 Force Autotune Restart - same as power-up. You can ignore this command
   
0xA0 1st in sequence to change I2C address
0xA5 3rd in sequence to change I2C address
0xAA 2nd in sequence to change I2C address


Quelle: www.robot-electronics.co.uk/htm/srf02tech.htm


Die Kommunikation mit dem SRF02 erfolt über Serielle Schnittstelle oder I²C. Die folgenden Beispielprogramme werden ausschließlich im I²C Modus vorgestellt.


Das Befehlsregister, mit dem die verschiedenen Befehle ausgeführt werden können, ist das Register 0. Um einen Befehl auszuführen muss lediglich der enstsprechende Befehlscode in das Register geschrieben werden.



//ground
#include <SoftwareSerial.h>
#include <Wire.h>
 
//----------config starts here-----------
const boolean useI2c = true; //srf02 mit i2c oder uart
const byte temperature =  21;      //temperature in Celsius
//const byte receiverAddress = 2; //uart = i2c - 112;
const byte receiverAddress = 114; //i2c = uart + 112
//----------config ends here-------------
 
const float speedOfSound =  0.0200457 * sqrt(temperature + 273.15);      //speed of sound mm/µs
unsigned int receiverReading = 0;
SoftwareSerial srf02(10, 11); // RX, TX
 
void setup()
{
  Wire.begin();
  srf02.begin(9600);
  Serial.begin(9600);          // start serial communication at 9600bps
  Serial.println("Start");
  /* Set address to E0
  int newAddress = 224;
  for (int i=0;i<16;i++) {
    oldAddress = 112 +i;
    changeAddress(byte(oldAddress), byte(newAddress));
  }
  */
}
 
 
void loop()
{
  int reading = 0;
  if (useI2c) {
    i2cStartMeasurement(byte(receiverAddress));
  } else {
    uartStartMeasurement(byte(receiverAddress));
    srf02.listen();
  }
  delay(70);    // datasheet suggests at least 65 milliseconds
  if (useI2c) {
    receiverReading = i2cGetMeasurement(byte(receiverAddress));
  } else {
    receiverReading = uartGetMeasurement(byte(receiverAddress));
  }
  Serial.print(receiverReading);
  Serial.print("\t|\t");
  receiverReading = receiverReading * speedOfSound;
  Serial.println(receiverReading);
  delay(200);
}
 
int uartGetMeasurement (byte address) {
  int reading = -1;
  srf02.write(address);
  srf02.write(0x5E);      // Get Range, returns two bytes (high byte first) from the most recent ranging.
  while (srf02.available() < 2);
  if (srf02.available() > 0) {
    reading = srf02.read();
  }
  reading = reading << 8;
  //while (srf02.available() == 0);
  if (srf02.available() > 0) {
    reading |= srf02.read();
  }
  return reading;
}
 
void uartStartMeasurement (byte address) {
  //address = (address >> 1) & 0x0F;
  srf02.write(address);
  srf02.write(0x52);
}
 
 
 
int i2cGetMeasurement (byte address) {
  int reading = -1;
  Wire.beginTransmission(address);     // transmit to device #112
  Wire.write(byte(0x02));              // sets register pointer to echo #1 register (0x02)
  Wire.endTransmission();              // stop transmitting
  Wire.requestFrom(address, byte(2));  // request 2 bytes from slave device #112
  if(2 <= Wire.available())            // if two bytes were received
  {
    reading = Wire.read();             // receive high byte (overwrites previous reading)
    reading = reading << 8;            // shift high byte to be high 8 bits
    reading |= Wire.read();            // receive low byte as lower 8 bits
  }
  return reading;
}
 
void i2cStartMeasurement (byte address) {
    Wire.beginTransmission(address);
    Wire.write(byte(0x00));
    Wire.write(byte(0x52));
    Wire.endTransmission();
}
 
void i2cFakeRange (byte address) {
    Wire.beginTransmission(address);
    Wire.write(byte(0x00));
    Wire.write(byte(0x5C));  //0x50  Real Ranging Mode - Result in inches
                             //0x51  Real Ranging Mode - Result in centimeters
                             //0x52  Real Ranging Mode - Result in micro-seconds
                             //0x56  Fake Ranging Mode - Result in inches
                             //0x57  Fake Ranging Mode - Result in centimeters
                             //0x58  Fake Ranging Mode - Result in micro-seconds
                             //0x5C  Transmit an 8 cycle 40khz burst
    Wire.endTransmission();
}
void i2cChangeAddress(byte oldAddress, byte newAddress)
{
// !! newAddress =  {224-239}
  Wire.beginTransmission(oldAddress);
  Wire.write(byte(0x00));
  Wire.write(byte(0xA0));
  Wire.endTransmission();
 
  Wire.beginTransmission(oldAddress);
  Wire.write(byte(0x00));
  Wire.write(byte(0xAA));
  Wire.endTransmission();
 
  Wire.beginTransmission(oldAddress);
  Wire.write(byte(0x00));
  Wire.write(byte(0xA5));
  Wire.endTransmission();
 
  Wire.beginTransmission(oldAddress);
  Wire.write(byte(0x00));
  Wire.write(newAddress);
  Wire.endTransmission();
}

a
Ultrasonic Sensor Operation on a Quadcopter.pdf

http://www.daedalus.ei.tum.de/index.php/de/archiv/material/sensoren/ultraschallsensor-srf02





9. Ultraschallsensor  MB1240

Ultraschallsensor  MB1240 

Pinbelegung:

  • Pin 1: Für serielle Ausgabe an Pin5 high setzten
  • Pin 2: (PW) Wird im untenstehenden Beispiel verwendet
  • Pin 3: (AN) Analoger Ausgang mit einer Skalierung von (VCC/1024) pro Zentimeter. Bei einer Versorgungsspannung von 5V erhält man ca. 4,9mV/cm und eine Reichweite von 700cm, bei 3,3V erhält man nur noch ca. 3,2mV/cm und die Reichweite schrumpft auf 600cm
  • Pin 4: (RX)
  • Pin 5: (TX)
  • V+: 3,3V - 5V Versorgungsspannung
  • GND: Ground und V+ müssen ripple- und rauscharm sein für optimalen Betrieb


/*
 * Ultraschallsensor(MB1240)
 */
  
long value = 0;                      // Variable für die Zeit vom US-Sensor zum Objekt
long high = 0;                       // Variable für die Entfernung vom US-Sensor zum Objekt
 
const int us    = A1;                // US Pin 2  an Pin A1
int Entfernung = 0;
 
void setup()
{
  Serial.begin(9600);                // Baudrate
  pinMode(us, INPUT);                // US-Pin als Eingang festlegen
   
  Serial.println("DISTANCE");
  Serial.println("cm");
 }
 
void loop()
{
  value = pulseIn(us, HIGH);         // Berechnungen
  high = value*(1000/58);
  Entfernung = high/1000;
   
  Serial.print(Entfernung);
  Serial.println("cm");
   
  delay(20);                         // Zeit bis zur nächsten Messung in ms
 
}


High Performance Ultrasonic Rangefinder

MB1240 XL-MaxSonar-EZ4

http://www.daedalus.ei.tum.de/index.php/de/archiv/material/sensoren/ultraschallsensor-mb1240

http://www.maxbotix.com/Ultrasonic_Sensors/MB1240.htm




10. TILT Sensor  RPI-1031

TILT Sensor  RPI-1031

Sensordaten:
Die Funktionsweise dieses Sensors ist ziemlich trivial. Eine kleine, freibewegliche Kugel innerhalb des Sensors schlägt je nachdem in welche Richtung der Sensor bewegt wird gegen eine Wand.

Die 2 digitalen Ausgänge detektieren dabei welche Wand berührt wird (LOW/LOW, LOW/HIGH, HIGH/LOW oder HIGH/HIGH) und geben dem entsprechend 0,1,2 oder 3 aus.

Pinbelegung:
VCC: 3,3V Versorgungsspannung
GND: Ground
S1: Digitaler Ausgang
S2: Digitaler Ausgang


SparkFun Tilt-a-Whirl Breakout - RPI-1031
SEN-12011
https://www.sparkfun.com/products/12011
https://www.sparkfun.com/products/retired/10621

http://www.daedalus.ei.tum.de/index.php/de/archiv/material/sensoren/tilt-sensor-rpi-1031




11. Real Time Clock  DS1307

Real Time Clock  DS1307

Wird der Arduino vom Akku getrennt entlädt sich der Kondensator der Uhr zu schnell und somit schafft es die DS1307 nicht rechtzeitig in den Batterie-Modus zu wechslen.
Dadurch verfälscht sich die eingestellte Zeit und eventuell das Datum.
Um dieses zu verhindern einen Schiebeschalter vor den VCC-Pin löten, der vorm abstecken des Arduinos betätigt wird.

// Date and time functions using a DS1307 RTC connected via I2C and Wire lib
  
#include <Wire.h>
#include "RTClib.h"
  
RTC_DS1307 RTC;
  
void setup () {
    Serial.begin(9600);
    Wire.begin();
    RTC.begin();
  
   // RTC.adjust(DateTime(__DATE__, __TIME__));
  
  if (! RTC.isrunning()) {
    Serial.println("RTC is NOT running!");
    // following line sets the RTC to the date & time this sketch was compiled
    RTC.adjust(DateTime(__DATE__, __TIME__));
 
  }
  
}
  
void loop () {
    DateTime now = RTC.now();
  
    Serial.print(now.day(), DEC);
    Serial.print('/');
    Serial.print(now.month(), DEC);
    Serial.print('/');
    Serial.print(now.year(), DEC);
    Serial.print(' ');
  
  
  
  
    if(now.hour()<10){
      Serial.print("0");
      Serial.print(now.hour(), DEC);
    }
    else{
      Serial.print(now.hour(), DEC);
    }
    Serial.print(':');
     
    if(now.minute()<10){
      Serial.print("0");
      Serial.print(now.minute(), DEC);
    }
    else{
      Serial.print(now.minute(), DEC);
    }
     
    Serial.print(':');
     
    if(now.second()<10){
      Serial.print("0");
      Serial.print(now.second(), DEC);
    }
    else{
      Serial.print(now.second(), DEC);
    
    Serial.print(" ");
     
    Serial.print(now.unixtime());
     
    Serial.println();
    Serial.println();
    delay(1000);
}


Datenblatt:
http://www.daedalus.ei.tum.de/attachments/article/63/Real Time Clock DS1307.pdf
http://www.daedalus.ei.tum.de/attachments/article/63/Real%20Time%20Clock%20DS1307.pdf
http://www.daedalus.ei.tum.de/index.php/de/archiv/material/sensoren/real-time-clock-ds1307





12. Luftfeuchtigkeitssensor DHT11

Luftfeuchtigkeitssensor  DHT11

Mit dem DHT11 können sowohl Temperatur als auch die Luftfeuchtigkeit gemessen werden.

Für den ###Datenlogger wird allerdings nur die Luffeuchtigkeit benötigt, da die Temperatur mit dem Drucksensor ###BMP085 genauer bestimmt werden kann.

/*  Feuchtigkeits Temperatur Sensor (DHT11)
 
 *
 */
 
 
#define DHT11_PIN 0      // ADC0
 
byte read_dht11_dat()
{
  byte i = 0;
  byte result=0;
  for(i=0; i< 8; i++)
  {
    while(!(PINC & _BV(DHT11_PIN)));  // wait for 50us
    delayMicroseconds(30);
    if(PINC & _BV(DHT11_PIN))
      result |=(1<<(7-i));
    while((PINC & _BV(DHT11_PIN)));  // wait '1' finish
    }
    return result;
}
 
 
void setup()
{
  DDRC |= _BV(DHT11_PIN);
  PORTC |= _BV(DHT11_PIN);
  Serial.begin(9600);
  Serial.println("Ready");
}
     
void loop()
{
  byte dht11_dat[5];
  byte dht11_in;
  byte i;// start condition
     // 1. pull-down i/o pin from 18ms
  PORTC &= ~_BV(DHT11_PIN);
  delay(18);
  PORTC |= _BV(DHT11_PIN);
  delayMicroseconds(40);
  DDRC &= ~_BV(DHT11_PIN);
  delayMicroseconds(40);
   
  dht11_in = PINC & _BV(DHT11_PIN);
  if(dht11_in)
  {
    Serial.println("dht11 start condition 1 not met");
    return;
  }
  delayMicroseconds(80);
  dht11_in = PINC & _BV(DHT11_PIN);
  if(!dht11_in)
  {
    Serial.println("dht11 start condition 2 not met");
    return;
  }
   
  delayMicroseconds(80);// now ready for data reception
  for (i=0; i<5; i++)
    dht11_dat[i] = read_dht11_dat();
  DDRC |= _BV(DHT11_PIN);
  PORTC |= _BV(DHT11_PIN);
  byte dht11_check_sum = dht11_dat[0]+dht11_dat[1]+dht11_dat[2]+dht11_dat[3];// check check_sum
  if(dht11_dat[4]!= dht11_check_sum)
  {
    Serial.println("DHT11 checksum error");
  }
  Serial.print("Current humdity = ");
  Serial.print(dht11_dat[0], DEC);
  Serial.print(".");
  Serial.print(dht11_dat[1], DEC);
  Serial.print("%  ");
  Serial.print("temperature = ");
  Serial.print(dht11_dat[2], DEC);
  Serial.print(".");
  Serial.print(dht11_dat[3], DEC);
  Serial.println("C  ");
  delay(2000);
}
http://www.daedalus.ei.tum.de/index.php/de/archiv/material/sensoren/luftfeuchtigkeitssensor-dht11







13. Luftdrucksensor BOSCH BMP085

Testmessung über eine Stunde mit dem annähernd lichtdicht eingepackten BMP085:

ungefilterte Messdaten in hPa




gefilterte Messdaten in hPa (Durchschnitt über 20 Messungen)

Testmessung im Treppenhaus


ungefilterte Messreihe


gefilterte Messreihe


Histogramm der Sensormessungen im "High Resolution Mode". ~23000 Messungen über den Zeitraum von einer Stunde. Varianz laut Octave: var(daten) = 0.39

Adresse

A7 A6 A5 A4 A3 A2 A1 W/R
1 1 1 0 1 1 1 0/1



Programmcode:

/*
 *  Taster für BMP085
 *  Durch Betätigen des Tasters wird der Luftdruck bei N.N. angepasst
 
 *
 *  Pinbelegung:
 *  - 2(arduino pro mini) - Taster
 */
 
#include <Wire.h>
#include <Adafruit_BMP085.h>
#include<math.h>;
 
Adafruit_BMP085 bmp;
 
int button = 2;              // switch is connected to pin 2
int val;                        // variable for reading the pin status
int buttonState;                // variable to hold the last button state
double altitude = 518.0;
double pressureAtSealevel = 0;
double relativ = 0;
 
 
/*****************************************************************************************************************/
/*                                     Funktion für pressureAtSealevel                                           */
/*****************************************************************************************************************/
 
double setPressureAtSealevel(double high, double pressure) {
  return (double)(pressure/pow(((double)1.0-((double)high/(double)44330.0)), (double)5.255));
}
 
/*****************************************************************************************************************/
/*                                             void setup()                                                      */
/*****************************************************************************************************************/
 
void setup() {
  pinMode(button, INPUT);  
  Serial.begin(9600);
  buttonState = digitalRead(button);   // read the initial state
  bmp.begin(BMP085_HIGHRES);
   
  
  pressureAtSealevel = setPressureAtSealevel(altitude, (double)bmp.readPressure() );
  Serial.print("pressureAtSealevel: ");
  Serial.print(pressureAtSealevel);
  Serial.println();
  Serial.print("START loop ");
  Serial.println();
  
}
 
/*****************************************************************************************************************/
/*                                               void loop()                                                     */
/*****************************************************************************************************************/
 
void loop(){
    val = digitalRead(button);
     
    if (val != buttonState) {                                              // the button state has changed!
     Serial.println("****************************************");
     Serial.println("Button just pressed");
     pressureAtSealevel = setPressureAtSealevel(altitude, (double)bmp.readPressure() );
     Serial.print("pressureAtSealevel changed to: ");
     Serial.println(pressureAtSealevel);
     Serial.println("****************************************");
    }
 
    relativ = bmp.readAltitude(pressureAtSealevel) - altitude;
   
    Serial.print(" Pressure = ");
    Serial.print(bmp.readPressure());
    Serial.print(" Pa");
     
    Serial.print(" Real altitude = ");
    Serial.print(bmp.readAltitude(pressureAtSealevel));
    Serial.print(" m");
         
    Serial.print(" Relative altitude = ");
    Serial.print(relativ);
    Serial.print(" m");
    Serial.println();
   
    delay(500);
   
}



http://www.daedalus.ei.tum.de/attachments/article/60/BST-BMP085-DS000-05%20Drucksensor.pdf
http://www.daedalus.ei.tum.de/index.php/de/archiv/material/sensoren/luftdrucksensor-bmp085







14. Luftdrucksensor  MS5611
http://www.daedalus.ei.tum.de/attachments/article/61/MS5611-01BA01.pdf

MS5611-01BA

Complementary Filtering High Res Barometer and Accelerometer for Reliable Altitude Estimation

Dies ist ein einfaches Beispiel für einige der Sachen, die ich vor kurzem gearbeitet habe. Dies ist eine Demonstration der in Kürze freizugebenden Filterfunktionen der FreeIMU-Bibliothek mit der FreeIMU v0.4.3 als Sensorboard.

Der Sensor-Fusionsalgorithmus schätzt die Orientierung der Platine ab, und daraus wird eine Abschätzung der dynamischen Beschleunigung berechnet, indem die Schwerkraft von den Beschleunigungsmesserablesungen subtrahiert wird. Die dynamische Beschleunigung wird mit den hochauflösenden Barometermessungen des MS5611 durch ein Komplementärfilter verschmolzen.

Das Ergebnis, wie in den Graphen zu sehen ist, ist eine äußerst zuverlässige Höhenschätzung, die bis zu 5-10 cm Präzision mit fast sofortiger Reaktion auf Bewegung gehen kann.

http://www.varesano.net/topic/ms5611-01ba

Datenblatt: MS5611-01BA01.pdf

http://www.daedalus.ei.tum.de/index.php/de/archiv/material/sensoren/luftdrucksensor-ms5611







15. Kompass Modul  HMC5883L




#include <Wire.h>
 
 
int8_t data[6];
int16_t x;
int16_t z;
int16_t y;
uint16_t phi;
 
 
 
/*****************************************************************************************************************/
/*                               Funktion zum Ausgeben und Berechnen des Kompasswertes                           */
/*****************************************************************************************************************/
 
int8_t printKompass(){
  int8_t rueckgabe;
  
  Wire.beginTransmission(30);
  Wire.write(2);
  Wire.write(1);
  Wire.endTransmission();
   
  delay(100);
   
  Wire.requestFrom(30,6);
  int j=0;
  while(Wire.available()){
   data[j] = Wire.read();
   j++;
  }
   
  x=((((int16_t)data[0])<<8)|(int16_t)data[1]);
  z=((((int16_t)data[2])<<8)|(int16_t)data[3]);
  y=((((int16_t)data[4])<<8)|(int16_t)data[5]);
   
  phi=((atan2(x,y)+3.1416)/(2.0*3.1416))*360.0;
   
  Serial.print(x);
  Serial.print(" ");
  Serial.print(y);
  Serial.print(" ");
  Serial.print(z);
  Serial.print(" ");
  Serial.println(phi);
   
  Wire.beginTransmission(30);
  Wire.write(3);
  Wire.endTransmission();
   
   
  return rueckgabe;
}
 
/*****************************************************************************************************************/
/*                                         Funktion zum Starten des Kompass                                      */
/*****************************************************************************************************************/
 
uint8_t startKompass(){
  uint8_t rueckgabe;
   
  delay(70);
   
  Wire.begin();
  Wire.beginTransmission(30);
  Wire.write((uint8_t)0);
  Wire.write(112);
 
  Wire.beginTransmission((uint8_t)30);
  Wire.write((uint8_t)1);
  Wire.write((uint8_t)160);
  Wire.endTransmission();
 
  return rueckgabe;
}
 
 
void setup(){
   
  Serial.begin(9600);
  startKompass();
  
}
 
void loop(){
   
  printKompass();
   
   
}


Datenblatt:
http://www.daedalus.ei.tum.de/attachments/article/59/3-Axis%20Digital%20Compass%20HMC5883L-FDS.pdf

http://www.daedalus.ei.tum.de/index.php/de/archiv/material/sensoren/kompass-hmc5883l




16. Lichtsensor  TEMT6000

Lichtsensor  TEMT6000


Sensordaten:
Der TEMT6000 ist ein epitaktischer NPN Silizium Phototransistor der empfindlich im sichtbaren Spektralbereich ist.

Die Ausgabe der gemessenen Werte erfolgt in Lux (lx).

Pinbelegung:
SIG: Analoger Ausgang
GND: Ground
VCC: 5V

/*
 * Lichtsensor(TEMT6000)
 *
 */
 
 
int licht = 0;
 
void setup(){
 Serial.begin(9600);
}
 
void loop(){
 licht = analogRead(3);
 Serial.print("Licht: ");
 Serial.println(licht, DEC);
 delay(200);
}

https://www.sparkfun.com/products/8688

http://www.daedalus.ei.tum.de/index.php/de/archiv/material/sensoren/lichtsensor-temt6000





17. Motion Processing Unit  MPU-6000 und MPU6050

http://www.varesano.net/topic/ms5611-01ba
http://playground.arduino.cc/Main/MPU-6050
https://create.arduino.cc/projecthub/Aritro/getting-started-with-imu-6-dof-motion-sensor-96e066
https://diyhacking.com/arduino-mpu-6050-imu-sensor-tutorial/
http://www.instructables.com/id/MPU6050-Arduino-6-Axis-Accelerometer-Gyro-GY-521-B/
https://www.sparkfun.com/products/11028

http://www.daedalus.ei.tum.de/index.php/de/archiv/material/sensoren/motion-processing-unit-mpu6050



18. Gyroskop  SD740



/*
Gyroscope SD740 SPI connection
  
 Version 1.0  Lauren <<script type="text/javascript">
 <!--
 var prefix = 'ma' + 'il' + 'to';
 var path = 'hr' + 'ef' + '=';
 var addy30661 = 'Lauran.pan' + '@';
 addy30661 = addy30661 + 'gmail' + '.' + 'com';
 document.write('<a ' + path + '\'' + prefix + ':' + addy30661 + '\'>');
 document.write(addy30661);
 document.write('<\/a>');
 //-->\n </script><a href="mailto:Lauran.pan@gmail.com">Lauran.pan@gmail.com</a><script type="text/javascript">
 <!--
 document.write('<span style=\'display: none;\'>');
 //-->
 </script><span style="display: none;">Diese E-Mail-Adresse ist vor Spambots geschützt! Zur Anzeige muss JavaScript eingeschaltet sein!
 <script type="text/javascript">
 <!--
 document.write('</');
 document.write('span>');
 //-->
 </script></span>> 
  
 Pin connection to the Arduino board:
  
 CSN         ->   digital pin 10(D10)
 MOSI/SDA    ->   digital pin 11(D11)
 MISO/ADDR   ->   digital pin 12(D12)
 SCL         ->   digital pin 13(D13)
  
 Operating Supply Voltage           V    2.6 - 5% - 3.3 + 5%
 Full Scale Range (digital output) °/s  1024
 Sensitivity Accuracy               %    ± 5
 Sensitivity Error Over Temperature %    ± 5
 Signal Update Rate                 KHz  10
 SPI Communication Speed            MHz  40
  
 Full scale range is factory defined. Please contact SensorDynamics for setting different ranges. Maximum full scale
 factor is 4096°/s
 Bandwidth is factory defined. Please contact SensorDynamics for setting different ranges. Maximum bandwidth is
 150Hz
  
 */
 
 
#include <SPI.h>
 
#define DataRegister 0x00
#define CS_Pin 10            //chip selection pin
 
char receiveData[128];        //data array
int x,y,z;
float xg,yg,zg;
float absHeading = 0;         // calculate the absolute heading
unsigned long iTime = 0;     
 
void setup(){
 
  Serial.begin(9600);
 
  SPI.begin();
  SPI.setDataMode(SPI_MODE0);
 
  pinMode(CS_Pin, OUTPUT);// init the chip selection pin
  digitalWrite(CS_Pin, HIGH);
 
  checkGyroStatus();
   
}
 
void checkGyroStatus(){
 
  readRegister(20,1,receiveData);
  Serial.print("check lock state:\t");
  Serial.println(receiveData[0],BIN);//bin; 110 means works well
   
  if(bitRead(receiveData[0],1) == 0 || bitRead(receiveData[0],2) == 0){
    Serial.println("Chip start error! You could reset the arduino board");
    while(1){
    }
  }
 
  readRegister(70,1,receiveData);
  Serial.print("check standby bit:\t");
  Serial.println(receiveData[0],BIN);//check bit0 0->normal 1->standby
   
}
 
void loop(){
   
  readRegister(DataRegister, 6, receiveData);
 
  x = ((int)receiveData[0]<<8)|(int)receiveData[1];
  y = ((int)receiveData[2]<<8)|(int)receiveData[3];
  z = ((int)receiveData[4]<<8)|(int)receiveData[5];
 
  float scale = 0.03125;// scale: 1024 / 2^15
 
  xg = x * scale;
  yg = y * scale;
  zg = z * scale;
  float pastTime = float(micros() - iTime) / float(1000000);
  absHeading += zg * pastTime;
  iTime = micros();
 
  Serial.print(x, DEC);
  Serial.print(',');
  Serial.print(y, DEC);
  Serial.print(',');
  Serial.print(z, DEC);
  Serial.print((float)xg,2);
  Serial.print("\t");
  Serial.print((float)yg,2);
  Serial.print("\t");
  Serial.print((float)zg,2);
  Serial.println(" °/s");
   
  Serial.print("Heading:");
  Serial.println(absHeading);//Axis Z absolute heading
   
 
  delay(1000);
 
}
 
void writeRegister(char registerAddress, char value){
 
  digitalWrite(CS_Pin, LOW);
  SPI.transfer(registerAddress);
  SPI.transfer(value);
  digitalWrite(CS_Pin, HIGH);
 
}
 
 
void readRegister(char registerAddress, int numBytes, char * values){
 
  char address = 0x80 | registerAddress;
  digitalWrite(CS_Pin, LOW);
  SPI.transfer(address);
  for(int i=0; i<numBytes; i++){
    values[i] = SPI.transfer(0x00);
  }
  digitalWrite(CS_Pin, HIGH);
 
}


http://www.daedalus.ei.tum.de/attachments/article/56/SD740_datasheet_v0_4.pdf
http://www.daedalus.ei.tum.de/index.php/de/archiv/material/sensoren/gyroskop-sd740






19. Beschleunigungssensor  ADXL345


#include <Wire.h>
 
#define DEVICE (0x53)    //ADXL345 device address
#define TO_READ (6)        //num of bytes we are going to read each time (two bytes for each axis)
 
byte buff[TO_READ] ;    //6 bytes buffer for saving data read from the device
char str[512];                      //string buffer to transform data before sending it to the serial port
double g = 9.806;
int time;
 
void setup()
{
  Wire.begin();        // join i2c bus (address optional for master)
  Serial.begin(9600);  // start serial for output
 
  //Turning on the ADXL345
  writeTo(DEVICE, 0x2D, 0);     
  writeTo(DEVICE, 0x2D, 16);
  writeTo(DEVICE, 0x2D, 8);
}
 
void loop()
{
//  Serial.println('Neue Messung');
//  while(true){
  int regAddress = 0x32;    //first axis-acceleration-data register on the ADXL345
  int x, y, z;
  double ax, ay , az;
  readFrom(DEVICE, regAddress, TO_READ, buff); //read the acceleration data from the ADXL345
 
  //each axis reading comes in 10 bit resolution, ie 2 bytes.  Least Significat Byte first!!
  //thus we are converting both bytes in to one int
  x = (((int)buff[1]) << 8) | buff[0];  
  y = (((int)buff[3])<< 8) | buff[2];
  z = (((int)buff[5]) << 8) | buff[4];
   
  time = millis();
   
  time = time * 0.001;
 
  //we send the x y z values as a string to the serial port
  sprintf(str, "%d %d %d", x, y, z); 
  Serial.print(str);
  Serial.print(" ");
  Serial.println(time);
 
  //It appears that delay is needed in order not to clog the port
  delay(50);
   
}
 
//---------------- Functions
//Writes val to address register on device
void writeTo(int device, byte address, byte val) {
  Wire.beginTransmission(device); //start transmission to device
  Wire.write(address);        // send register address
  Wire.write(val);        // send value to write
  Wire.endTransmission(); //end transmission
}
 
//reads num bytes starting from address register on device in to buff array
void readFrom(int device, byte address, int num, byte buff[]) {
  Wire.beginTransmission(device); //start transmission to device
  Wire.write(address);        //sends address to read from
  Wire.endTransmission(); //end transmission
 
    Wire.beginTransmission(device); //start transmission to device
  Wire.requestFrom(device, num);    // request 6 bytes from device
 
  int i = 0;
  while(Wire.available())    //device may send less than requested (abnormal)
  {
    buff[i] = Wire.read(); // receive a byte
    i++;
  }
  Wire.endTransmission(); //end transmission
 
}


http://www.daedalus.ei.tum.de/attachments/article/55/ADXL345-1.pdf
http://www.daedalus.ei.tum.de/index.php/de/archiv/material/sensoren/beschleunigungssensor-adxl345













*********************************************************
                                  Sensorarten

Inhaltsverzeichnis

Welche Sensorarten gibt es

Damit sich ein Roboter in seiner Umgebung bewegen kann, ohne an Hindernisse anzustoßen, und damit er ein Ziel finden und ansteuern kann, muß er irgendwie seine Umwelt "wahrnehmen". Hauptanwendung für diese Informationen aus der Umwelt ist die Navigation. Auf dieser Seite werden die wichtigsten Sensorarten und damit es praktischer wird auch zugleich die populärsten Robotik- und Modellbau-Sensortypen vorgestellt. Auch die Pinbelegung und Anschlussmöglichkeiten dieser Sensoren werden kurz erläutert.

Es ist auch möglich Informationen für die Steuerung des Roboters nicht nur aus eigens dafür gebaute Sensoren zu gewinnen. Durch Ausnutzung der Eigenschaften von schon vorhandenen Bauteilen können dadurch eventuell separate Sensoren eingespart werden. Beispiel ist im verlinkten Forumbeitrag unter den Weblinks zu finden.

Bumpers

Als Bumpers bezeichnet man eine Art Stoßstange, die einen Mikro-Switch auslöst.

Microschalter.jpg

Die Auswertung erfolgt am besten digital an einem Pin mit Pull-up Widerstand. Man kann den Eingang pollen (abfragen), aber auch einen Interrupt auslösen lassen. -->

Whiskers (Fühler)

Das sind flexible Kunststoff-Streifen von ca. 10 cm Länge, eigentlich für Datenhandschuhe vorgesehen. Aber man kann sie auch als Fühler einsetzen, und daher auch für die Kollisions-Sensorik verwenden. Beim Verbiegen steigt der Widerstand an.

Flexs 200.jpg

Um zu messen, wird mit einem zweiten Widerstand ein Spannungsteiler aufgebaut, der dann mit einem Analog-Eingang einen Grad der Verbiegung erkennen läßt. Sie werden häufig auch Flexsensoren genannt. -->

Magnetische Sensoren

Es gibt eine Vielzahl an magnetischen Sensoren für Winkel-, Weg-, Position- und Strommessung die die unterschiedlichen magnetischen Technologien verwenden. Eine der bekanntesten Technolgien ist die Nutzung des Hall-Effektes. Aber auch induktive oder magnetoresistive Technologie kann genutzt werden um magnetische Sensoren zu realisieren.

Weg-, Winkelsensoren

austriamicrosystems AS5040


AMS-general 200x200.jpg
AMS-chip 109x104.jpg

Der AS5040 kann absolute Winkelpositionen an einer Achse messen. Die Messung wird indirekt über ein Magnetfeld mittels Hallsensoren durchgeführt. Aufgrund der Anordnung der Hallsensoren und der Integration der Sensoren direkt in Silizium wird eine sehr hohe Genauigkeit bei der Messung erreicht. Das Messprinzip kompensiert ausserdem Störgrössen, wie externes Magnetfeld, Alterungseinflüsse, Temperaturschwankungen und mechanische Toleranzen.




Die komplette Auswertung der Sensorsignale geschieht auf dem Chip.



AMS-block 700x242.jpg


AMS-pcb 200x152.jpg




Durch die hohe Integration reduziert sich die zusätzliche Beschaltung des Chips auf wenige Bauteile, beispielsweise ein paar Filterkondensatoren.





Die Winkelencoderfamilie von austriamicrosystems besitzt vielfältige Schnittstellen, um den Winkelwert zu übertragen

Seriell SSI Standard Schnittstelle für Winkelencoder in der Industrie
PWM erzeugt abhängig vom Winkel eine entsprechende Pulslänge, läßt sich sehr schön mit der Capturefunktion eines Controllers messen und braucht nur eine Leitung
I2C direkte Schnittstelle zum Microcontroller
Analog kompatible Schnittstelle um beispielsweise Potiapplikationen zu ersetzen
Inkremental klassische Schnittstelle um relative Bewegungen zu messen, keine Absolutmessung möglich
BLDC erzeugt direkt die Kommutierung für einen bürstenlosen Motor. Durch die höhere Auflösung gegenüber einer 3-Hall-Schalterlösung kann der BLDC mit einem wesentlich höheren Drehmoment gestartet werden
AMS-magnet 354x421.jpg





Bei der Auswahl des Magnets ist darauf zu achten, dass sogenannte Selten-Erde-Magnete verwendet werden. http://de.wikipedia.org/wiki/Seltene_Erden Diese erzeugen ein besonders starkes Magnetfeld, das im 1-Tesla-Bereich liegt. Im Zentrum des Magnetfelds ist ein linearer Bereich, der für die Genauigkeit der Messung ausschlaggebend ist. Solange die Hallsensoren in diesem Bereich liegen, kann eine unkalibrierte Genauigkeit von +/- 0.5 Grad gewährleistet werden. Weiterhin ist zu beachten, dass der Magnet nicht direkt auf eine Eisenwelle montiert wird. Die Eisenwelle verursacht quasi einen magnetischen 'Kurzschluss' und entzieht damit den Hallsensoren das Magnetfeld. Idealerweise sollte eine NE-Welle verwendet werden, oder wenn nicht anders machbar muss eine Isolation aus NE-Material zwischen Eisenwelle und Magnet eingefügt werden.














Ein einfacher erfolgreicher Test des Sensors ist hier beschrieben: http://www.roboternetz.de/phpBB2/zeigebeitrag.php?p=322373#322373

Winkelsensor-Familie FREEPITCH Sensitec AA700

AA747 Signal.jpg

Die Sensoren der AA700 Familie sind Winkelsensoren, basierend auf dem anisotropen magnetoresistiven (AMR) Effekt. Die Sensor besteht aus zwei um 45° relativ zueinander verdrehten Wheatstone-Bücken. Ein rotierendes Magnetfeld in der Sensorebene liefert zwei um 90° zueinander phasenverschobene Sinussignale mit doppelter Frequenz des Magnetfeldes. Der AA747 ist in einem SO8-Gehäuse. Der AA745 ist in einem SIL6-Gehäuse.
FREEPITCH bedeutet, dass der Sensor quasi punktförmig über eine geringe Fläche die Magnetfeldrichtung erfasst.
Die Sensoren sind ein rein passiver Sensoren - haben also keine internen Verstärker o.ä. Halbleiterkomponenten. Die Sensoren sind somit "nur" ein Widerstandselement und hat dadurch eine sehr hohe Bandbreite.
Als Magnet kommt üblicherweise ein Dipolmagnet zum Einsatz, der oberhalb des Gehäuses in der Ebene des Sensors rotiert wird.

http://sensitec.com.p-ad.de/deutsch/produkte/winkel/aa747.html
http://sensitec.com.p-ad.de/deutsch/produkte/winkel/aa745.html

zur Übersicht und Auswahl des geeigneten Sensors und Magneten (Application note):
http://sensitec.com.p-ad.de/upload/SENSITEC/PDF_Downloads/Application_Note/Sensitec_AA700_AND_00.pdf





[Bildquelle: Sensitec: www.sensitec.com]

Längensensor-Familie FIXPITCH Sensitec AL700

Die Sensoren der AL700-Familie sind Längensensoren, basierend auf dem anisotropen magnetoresistiven (AMR) Effekt, angepasst an eine magnetische Pollänge. Die Sensoren bestehen aus zwei zueinander versetzten Wheatstone Bücken. Der Sensor liefert zwei um 90° zueinander phasenverschobene Sinussignale mit doppelter Frequenz des Magnetfeldes. Die Amplitude der Sensoren ist bis zu einem Abstand von etwa der hälfte der Polteilung zwischen Sensor und Maßverkörperung konstant. Da die Sensoren übicherweise an einem Magnetband mit abwechselnd magnetisierten Nord- und Südpolen benutzt werden, sind sie in einem SIL6-Gehäuse. Dies erlaubt es den Sensor an einer Leiterplattenkante zu bestücken.
Als Maßstab kommt wird ein Magnetband mit der zum Sensor passenden Polteilung benutzt. Diese Kombination sorgt für eine sehr gute Performance der Positionsmessung.
Weiterhin sind die Sensoren (bis auf den 5 mm Sensor) so aufgebaut, dass die MR-Messstreifen über mehrere magnetische Pole des Maßstabes angeordnet sind. Z.B. ist der Sensor AL798 (für 1 mm Pole) nur nur 1 mm breit, sondern 2 mm breit, weil er über zwei Magnetpole des Maßstabes "mittelt". Hierdurch wird erreicht, dass z.B. ungleich große Pole (die z.B. durch Materialinhomogenitäten des Maßstabes entstehen können) gemittelt werden und somit der "Fehler" des einzelnen Poles nicht so stark in das Positionsergebnis eingeht.

AL700 Pitch.jpg

Polteilung 0,5 mm: http://sensitec.com.p-ad.de/deutsch/produkte/winkel/al795.html
Polteilung 1 mm: http://sensitec.com.p-ad.de/deutsch/produkte/winkel/al798.html
Polteilung 2 mm: http://sensitec.com.p-ad.de/deutsch/produkte/winkel/al796.html
Polteilung 2,5 mm: http://sensitec.com.p-ad.de/deutsch/produkte/winkel/al797.html
Polteilung 5 mm: http://sensitec.com.p-ad.de/deutsch/produkte/winkel/al780.html

zur Auswahl des Sensors, der Messanordnung und des Maßsstabes gibts hier eine Übersicht (Application note):
http://sensitec.com.p-ad.de/upload/SENSITEC/PDF_Downloads/Application_Note/Sensitec_Aktive_Maverkrperungen_AND_00.pdf

[Bildquelle: Sensitec: www.sensitec.com]

Stromsensoren

Sensitec CMS3000 & CDS4000

Die Stromsensoren der CMS3000- und CDS4000-Reihe basieren auf der magnetoresistiven Technologie und sind nach dem Kompensationsprinzip aufgebaut, dies bringt eine sehr genaue (sehr lineare) Strommessung.
Folgende Strombereiche sind verfügbar:

Typ Nennstrom Versorgung
CMS3005 5 A ±15 V
CDS4006 6 A 5 V
CDS4010 10 A 5 V
CMS3015 15 A ±15 V
CDS4015 15 A 5 V
CMS3025 25 A ±15 V
CDS4015 25 A 5 V
CMS3050 50 A ±15 V
CDS4050 50 A 5 V
CDS4100 100 A 5 V
CDS4125 125 A 5 V
CDS4150 150 A 5 V

Weiterhin kann durch den Sensoren der 3fache Nennstrom (also z.B. bei 50 A bis zu 150 A) abgebildet werden.

Optische Sensoren

Helligkeit

Die Hauptanwendung solcher Sensoren ist, den hellsten Fleck im Raum zu finden. Dies ist auch Teil vieler Roboterwettbewerbe. (Robo Callenge (2002 sic!), 'Ein Platz an der Sonne')

Solche Sensoren können einfache LDRs oder Photodioden bzw. Phototransistoren sein. LDRs haben den Vorteil, dass sie relativ hoch aussteuern, der große Nachteil ist aber, dass diese Sensoren ziemlich wärmeempfindlich und träge sind (Der Dunkelwiderstand wird erst nach 1-60s wieder erreicht). Photodioden und Phototransistoren haben den Vorteil, dass sie sehr genau sind, aber nicht besonders hoch aussteuern. Diese sollte man evtl. über einen OpAmp verstärken.

Grössenordnung der Grenzfrequenzen: Photowidertand ca. 10-100 Hz Photodarlington-Transistor ca. 30 kHz Photo-Transistor ca. 300 kHz Photo-Diode ca. 10 MHz Photo-Pin-Diode ca. 1 GHz

Ein typischer Fotowiderstand


SFH300, ein typischer Phototransistor

Alternativ kann auch ein digitaler Lichtsensor verwendet werden, den man direkt an den I2C- oder SM-Bus anschliessen kann. Man erspart sich Auswertung, Temperaturkompensation und Signalaufbereitung, allerdings ist der Anschluss meistens schwieriger, weil der Sensor in SMD-Bauform gebaut ist und 3,3 anstatt 5 Volt braucht.

Datei:Lichtsensor.jpg
Ein digitaler Lichtsensor für den I2C-Bus (TSL2561 der Frima Taos)

Die Suche nach dem hellsten Fleck im Raum ist wie ich finde ein gutes Einsteigerthema!

CNY70

Der CNY70 ist ein Foto-Reflex-Optokoppler. In einem würfelförmigem Gehäuse befindet sich eine Infrarot-LED als Sender und ein Infrarot-Fototransistor als Empfänger. Damit kann auf kurze Entfernung (wenige Millimeter) das reflektierte Licht der IR-LED durch den IR-Fototransistor gemessen werden.

Er wird häufig als Sensoren bei einem Linienfolger-Roboter verwendet. Die Reichweite ist jedoch sehr gering, sodass der Abstand zur abgetasteten Fläche klein sein muss. Die maximale Empfindlichkeit ist bei einem Abstand von 0,3mm. Bei etwa 7mm ist die Empfindlichkeit nur noch 10% vom Maximalwert.

siehe CNY70

Distanzsensor IS471F

IS471F - Hinderniserkennung mit Infrarot Distanzsensor

Das hier vorgestellte IC IS471F erlaubt eine einfache und sogar recht preisgünstige Hinderniserkennung per Infrarot. Dazu muss im Wesentlichen nur noch eine Infrarot-Diode an das IC angeschlossen werden. Das modulierte Licht wird von einem Gegenstand direkt auf das IC zurückgeworfen und somit das Hindernis erkannt. Tageslicht/Fremdlicht stört den IS471 überhaupt nicht, da das Licht mit einer bestimmten Frequenz moduliert wird.


Is471.png


Der normale Schaltungsaufbau sieht also wie oben abgebildet aus! In der Praxis kann das dann in etwa so aussehen:


Is471beispiel.jpg


Das englische Datenblatt findet man im Roboternetz-Download-Bereich

Die normale Reichweite ist in gewissen Grenzen abhängig von der Farbe des Hindernisses. In der Regel reicht sie jedoch einige cm, so dass langsame Roboter durchaus sehr gut damit zurechtkommen. Durch besonders helle Infrarot-LEDs und durch zusätzliche LED-Fassungen kann man die Reichweite erhöhen. Wem das noch nicht reicht, der kann über einen zusätzlichen Transistor die Strahlungsleistung der LED noch weiter erhöhen.

Is471verstaerkung.png


http://www.roboternetz.de/bilder/mehrereis471.gif

Sharp Infrarotsensoren

Sharp hat eine ganz interessante Serie von Bausteinen herausgebracht, mit denen ein Roboter sogar recht genau Entfernungen messen kann. Das Messergebnis ist nahezu unabhängig von der Farbe und Helligkeit des gemessenen Objektes. Die Ansteuerung ist sehr einfach, der Sensorausgang kann zum Beispiel direkt an einen analogen Eingang eines Mikrocontrollers angeschlossen werden. Die Sensoren sind unter den Roboter-Bastlern weit verbreitet. Bei vielen Händlern erhältlich kosten die Sensoren derzeit je nach Typ und Händlerspanne zwischen 13 bis 25 Euro.

Sharpentfernungssensor.jpg


Oft werden selbst in kleinen Roboter-Projekten mehrere dieser Sensoren genutzt, da sie nur einen äußerst engen Erfassungsbereich haben. Sie eignen sich daher sehr gut zur Vermessung einer Umgebung, insbesondere dann, wenn sie drehbar auf einem Servo montiert werden. Als Kollisionsschutz sind sie wegen des engen Winkels nur bedingt geeignet, zu diesem Zweck eignen sich zum Beispiel Ultraschallsensoren besser. Das Funktionsprinzip der Sensoren ist einfach. Der Sensor besteht aus Sender und Empfänger. Der Sender sendet einen Infrarot-Strahl aus, der vom Hindernis reflektiert wird. Je nach Entfernung trifft der reflektierte Strahl an einer unterschiedlichen Stelle auf den Empfänger (ein sog. Position Sensitive Device, PSD). Der Empfänger setzt den Auftreffpunkt in einen analogen Spannungswert um. Eine schöne Skizze dazu:

Sharpfunktion.jpg

Wenn man diese Sensoren an Robotern einsetzt, will man meist Hindernisse mit senkrecht stehenden Kanten erkennen. Montiert man den Sensor jedoch in waagrechter Lage, können sich Fehlmessungen ergeben, wenn sich ein Objekt am Sensor vorbeibewegt (z.B. wenn sich der Roboter dreht). Es wird an der Kante kurzzeitig eine Entfernung gemessen, die geringer als die tatsächliche Entfernung zum Hindernis ist (oder auch größer als die Entfernung zu einem zweiten Hindernis hinter dem ersten, je nach Bewegungsrichtung!). Man löst dieses Problem, indem man den Sensor in senkrechter Position montiert, also so, dass die beiden Linsen übereinander statt nebeneinander liegen. Dies wird auch im Datenblatt des Sensors empfohlen: der Sensor sollte immer senkrecht zur Bewegungsrichtung des Hindernisses montiert werden.

Sehr deutlich erkennt man diese Messfehler, wenn man den Sensor als eine Art 3D-Scanner einsetzt: http://www.team-iwan.de/technik/sharp1.php

Die Gehäuse dieser Sensoren sehen wie ganz gewöhnlicher Kunststoff aus. Sie bestehen jedoch aus leitfähigem Material! (Kaum zu glauben, aber einfach nachprüfbar: zwischen den beiden Befestigungslöchern misst man einen Widerstand von etwa 250 bis 300 Ohm). Außerdem ist das Gehäuse mit dem Masseanschluss verbunden. Dies ist normalerweise nicht weiter wichtig, da die Sensoren meist entweder isoliert (zB auf Kunststoffteilen) oder auf einem geerdeten/mit Masse verbundenen Metallchassis montiert werden. Wenn man aber die Sensoren abschalten will, um Strom zu sparen (die Sensoren verbrauchen etwa 30 bis 40mA), muss man bei nicht isolierter Montage unbedingt die Plusleitung schalten! Wenn man die Masse-Zuleitung unterbricht, ist der Sensor sonst trotzdem noch über das Gehäuse und das Chassis mit Masse verbunden und wird nicht deaktiviert!

Filter für einen analogen SHARP-Sensor zur Vermeidung von Störungen auf der +5V Versorgung und dem Ausgang.

Die Stromaufnahme des Sensors von 30-40mA kann täuschen. Mit einer Wiederholrate von etwa 1kHz benötigt der Sensor kurzzeitig eine Stromaufnahme von ca. 1 Ampere! Diese Stromstärke braucht der Sharp-Sensor, um damit seine Infrarot-Sende-LED zu treiben. Durch die hohe Stromaufnahme kann der Sensor infrarotes Licht kurzzeitig mit hoher Intensität aussenden. Die Verwendung eines oder sogar mehrerer IR-Distanzsensoren dieser Sorte kann zu erheblichen Spannungseinbrüchen auf der 5V-Versorgungsleitung führen. Am Analogausgang des Sensors können ebenso noch Störungen vorhanden sein. Um Rückwirkungen auf die Versorgung zu vermeiden und die Störungen auf der Ausgangsleitung (für einen Sensor mit analogem Ausgang!) zu verringern, soll hier auf den nebenstehenden Schaltplan verwiesen werden. Der Elko vor dem Sensor sollte die angegebene Kapazität haben, da der Sharp-Sensor seine Stromspitzen hauptsächlich aus diesem bezieht. Dieser Elko wird über den 3,3-Ohm-Widerstand aufgeladen. Der Widerstand kann auch durch eine Induktivität ersetzt werden, Berechnung über thomsonsche Schwingungsformel f=1/(2*Pi*Wurzel(L*C)), wobei die Grenzfrequenz f deutlich kleiner als die 1kHz gewählt werden sollten, um die gewünschte Filterwirkung (Dämpfung) zu erreichen. Weitere Informationen: Thema im Roboternetz Untersuchung von Segor Electronics


Einige der beliebtesten Bausteine sind:

Sharp GP2D12

Distanz 10-80 cm - Entfernung wird durch analoge Spannung am Ausgang übermittelt. Dies ist der am häufigsten eingesetzte Sharp-Typ bei mobilen Robotern. Dieser Sensor wird seit 2010 nicht mehr produziert. Der Nachfolger ist der GP2Y0A21YK0F.


GP2D12anschluss.gif


Sharp GP2Y0A21YK0F (Nachfolger des GP2D12)

Distanz 10-80 cm - Entfernung wird durch analoge Spannung am Ausgang übermittelt.

GP2Y0A21YK0F.jpg
GP2Y0A21YK0F diagram.gif

Sharp GP2YA21YK

Distanz 10-80 cm - Entfernung wird durch analoge Spannung am Ausgang übermittelt.

Sharp GP2D120

Distanz 4-30 cm - Entfernung wird durch analoge Spannung am Ausgang übermittelt.

Sharp GP2Y0A02YK

Distanz 20-150 cm - Entfernung wird durch analoge Spannung am Ausgang übermittelt.

http://www.shop.robotikhardware.de/shop/catalog/images/artikelbilder/sensoren/gp2y0a02yk_diagramm.gif

Sharp GP2D02

Distanz 10-80 cm - Entfernung wird durch 8-Bit-Digitalausgang übermittelt.

Sharp GP2D150

Distanz 3-30 cm - 1 Bit Schaltausgang.


Datenblätter zu den oberen Sensoren findet man im Download-Bereich des Roboternetzes, siehe unter #Weblinks.

Um die analogen Spannungen der Sensoren in eine Entfernung umzurechnen, kann man sich mit Hilfe des Datenblattes oder einfacher Probemessungen Tabellen erstellen, welche dann vom Controller zur Umsetzung genutzt werden. Bequemer ist allerdings eine Näherungsformel:

Formel zur Entfernungsberechnung

D = A/(X-B) 
D ist die Entfernung 
X ist der Ausgabewert des Sensors 
A ist die Steigung der Kurve A/X 
B ist der Offset der Kurve 

Die Konstanten A und B ermittelt man am besten über zwei Probemessungen:

D und X sind die Entfernung und der Ausgabewert der ersten Messung (z.B. bei 20 cm) D' und X' sind die Entfernung und der Ausgabewert der zweiten Messung (z.B. bei 60 cm)

A = ((X' - X) * D' * D) /(D - D' ) 
B = (D' * X' - D * X) /(D' - D)

Mehrere Messungen ergeben ein besseres Ergebnis: Dazu werden für jeweils zwei Messungen die Konstanten A und B errechnet (s. o.) und in ein Plotprogramm als Graph dargestellt. Plotprogramm (OpenSource): Graph

Funktion: 
f(x)=A/(x-B)

Man kann dann durch Verändern von A und B einen Graphen erstellen, der die meisten Eigenschaften der anderen Graphen enthällt. Diese Konstanten entsprechen dann ziemlich genau dem Realwert.

GP2D12 Messkurve

Gpd12kurve.gif

GPD120 Messkurve

Gpd120kurve.gif


Messfleckgröße des SHARP GP2Y0A41SK0F

siehe

http://www.roboternetz.de/community/threads/55555-Messfleckgröße-des-SHARP-GP2Y0A41SK0F?p=530710&viewfull=1#post530710

Drehgeber Sharp GP1A30 und GP1A38

Gp1a30.jpg

Beim Sharp GP1A30 und GP1A38 handelt es sich um Gabellichtschranken mit inkrementaler Drehgeberfunktion. Beide sind im Grunde von den Anschlüssen identisch, lediglich kann GP1A38 noch etwas höhere Drehzahlen messen. Im Gegensatz zu herkömmlichen Gabellichtschranken können mit dieser sowohl Drehzahl als auch Drehrichtung ermittelt werden. Notwendig sind dafür nur 2 digitale Ports. Verzichtet man auf die Auswertung der Drehrichtung, reicht nur ein Port. Der Sensor hat den Vorteil, dass die Signale bereits TTL-kompatibel sind und direkt an ein Controllerboard angeschlossen werden können. Ein Beispielprogramm zu RN-Control findet man hier


GP1A30.gif

Die Auswertung inkrementaler Drehgeber ist recht einfach. Ein Ausgang liefert einen Impuls pro Markierung (Scheibe auf der Welle). Prüft man bei jedem Impuls (Flanke) noch gleichzeitig den aktuellen Pegel des zweiten Ausganges, so kann daraus die Drehrichtung abgeleitet werden.


Der Signalverlauf an den Sensorausgängen ist phasenversetzt:

Inkremental1.gif


Beispielschaltung, wenn man lediglich die Drehzahl ohne Drehrichtung auswerten möchte. Als Widerstand hat sich 330 Ohm als gut erwiesen.

Ultraschall Sensoren

Ultraschallsensoren SRF04

Die Firma Devantech hat eine Serie von sehr günstigen und kleinen Ultraschallsensoren entwickelt, die sich im Bereich "autonome Robotersysteme" durchgesetzt haben. Sie sind sehr verbreitet, da sie auch für "Hobby-Robotiker" erschwinglich sind und es sich nicht lohnen würde vergleichbare Module selber zu bauen, da diese meistens ungenauer und teurer wären.

Bekannt wurde die Serie durch den SRF04. Mit seinen kleinen Abmessungen, der niedrigen Stromaufnahme und der hohen Genauigkeit ist er für kleine Messaufgaben im Entfernungsbereich von 3 cm bis 3 m gut geeignet. Der SRF04 kann einen 3 cm dicken Besenstiel in 2 m Entfernung erkennen und wird durch ein PWM-Signal ausgewertet.

Srf 04a.jpg Srf 04.jpg

Ultraschallsensor SRF05

Der Nachfolger des SRF04 ist der neue SRF05. Er besitzt noch eine etwas höhere Reichweite bis 4 Meter. Zudem besitzt er neben dem kompatibel Mode zu SRF04 noch eine Betriebsart bei der er über einen einzigen Port (Pin) gesteuert wird. Das heißt sowohl der Start der Messung und das Ergebnis wird über die gleiche Leitung übertragen. Programmbeispiel in Bascom

Srf05mode1.jpg


Srf05mode2.gif


Srf05mode2diagram.gif

SRF08

Die Alternative zu SRF04 und SRF05 ist der beliebte SRF08 und dessen Nachfolger SRF10, der nun über den I2C-Bus ausgewertet werden kann und über eine Reichweite von 3 cm bis 6 m verfügt. Er hat eine noch kleinere Stromaufnahme und zusätzlich befindet sich auf der Platinenfront ein Fotowiderstand (LDR), dessen Lichtmesswerte sich ebenfalls über den I2C-Bus auswerten lassen. Durch den SRF08 wird es möglich, auch bis zu 16 Mehrfachechos von weiter hinten gelegenen Gegenständen auszuwerten, die bei dem SRF04 ignoriert wurden. Über den I2C-Bus kann man die Messwerte in Zentimeter, Zoll und in der Laufzeit µs auslesen und spart sich somit die externe Auswertung der Laufzeit wie bei dem SRF04. Weiterhin können insgesamt 16 SRF08-Module an einen I2C-Bus angeschlossen werden.

Srf08 a.jpg Srf08 b.jpg

SRF08 Programmbeispiel

SRF08 Programmbeispiel mit AVR-GCC

SFR08 Programmbeispiel mit Bascom Über die grundsätzliche Behandlung des I2C-Bus mit Bascom kann man hier nachlesen.

Const Sf08_adr_0 = &HE0             ' I2C Adresse
Const Sf08_c_range = 100            ' Reichweite
Const Sf08_c_gain = 1               ' Empfindlichkeit

Die Adresse ist der Default-Wert für den Sensor und kann eingestellt werden. Range und Gain sind anzupassen, die angegebenen Werte sind aber mal grundsätzlich verwendbar.

Setup Nach dem Reset sind einmal Range und Gain zu setzen.

Setzen Range

     I2cstart
     I2cwbyte Sf08_adr_0   ' Device I2C Adresse
     I2cwbyte 2            ' register "range"
     I2cwbyte Sf08_c_range  
     I2cstop

Setzen Gain

     I2cstart
     I2cwbyte Sf08_adr_0   ' Device I2C Adresse
     I2cwbyte 1            ' register "gain"
     I2cwbyte Sf08_c_gain    
     I2cstop

Abfrage Trigger

Die Abfrage soll laut Beschreibung in zwei Schritten erfolgen, zwischen denen ca 70 mS gewartet werden soll. Diese Zeit braucht das Gerät zum Messen.

Trigger

     I2cstart
     I2cwbyte Sf08_adr_0   ' Device I2C Adresse
     I2cwbyte 0            ' register "Trigger"
     I2cwbyte 81           ' Meßwert in Zentimetern
     Waitms 70 

Ergebnis abholen

 DIM Lsb as Byte
 DIM Msb as Byte
 DIM IVal as word

      I2cstart              ' Repeated Start
      I2cwbyte Sf08_adr_0   ' Device I2C Adresse
      I2cwbyte 2            ' Meßwert US

      I2cstart                 ' repeated Start
      I2cwbyte Sf08_adr_0 + 1  ' Device I2C Adresse READ!
      I2crbyte Msb , Ack      ' Bit 8-15
      I2crbyte Lsb , Nack     ' Bit 0-7
      I2cstop

      Ival = Makeint(lsb , Msb) ' umwandeln in Word (16 Bit)

SRF10 Ultraschallsensor

SRF10 ist quasi der Nachfolger von SRF08. Er bietet die gleiche Leistung und ist sogar gegenüber Spannungsschwankungen noch etwas unempfindlicher als der Vorgänger. Der größte Vorteil besteht jedoch darin das er ca. 1/3 kleiner als sein Vorgänger ist. Allerdings bietet er im Gegensatz zum SRF08 weder einen Lichtsensor noch die Möglichkeit, die Mehrfachechos auszulesen.

Srf10foto1.jpg Srf10foto2.gif

Die technischen Daten sind ähnlich:

  • Betriebsspannung: 5V
  • Stromaufnahme: ca. 3mA Standby, ca. 15mA während des Messens Frequenz: 40KHz
  • Maximale Reichweite: 6 m
  • Minimale Reichweite: 4 cm
  • Messwerterfassung: intern, kein externer Controller zur Zeitmessung notwendig
  • Interface: Standard – I2C (passend zu zahlreichen Controllerboards, z.B. RN-Control)
  • Ausgabeformat: µs, cm oder Zoll
  • Feature: Analogverstärkung 40 - 700 (einstellbar, 16 Stufen)
  • Abmessungen: 32mm x 15mm x 10mm
  • Hersteller: Devantech Ltd


Srf10ausbreitung.gif

SRF02 Ultraschallsensor

Der erste Sensor aus der SRF-Reihe, der mit nur einem Ultraschallwandler auskommt. Dennoch können sich die Leistungen zeigen. Vor allem die Tatsache, dass sowohl RS232- und I2C-Bus-Schnittstelle vorhanden ist, dürfte viele Bastler erfreuen.

  • Betriebsspannung 5V (stabilisiert)
  • Stromaufnahme nur 4mA (typisch)
  • Ultraschallfrequenz 40kHz
  • Reichweite 15 cm bis 6 Meter
  • Schnittstelle RS232 (TTL) und I2C-Bus
  • Ausgabeeinheit wahlweise mm, inch oder uS
  • Einfachste Verwendung, keine Kalibration/Justierung notwendig
  • Größe 24mm x 20mm x 17mm

Srf02 germany.jpg

Einige Bascom-Programmbeispiele zum SRF02 findet man unter Ultraschallsensor SRF02 am RN-Board

Vergleichstabelle


SRF10 SRF08 SRF05 SRF04 SRF02
Betr. Spannung 5V 5V 5V 5V 5V
Stromaufnahme 3mA typ.,
15mA max.
3mA typ.,
15mA max.
4mA typ.,
30mA max.
30mA typ.,
50mA max.
4mA typ.
 
US Leistung 100 – 150mW 100 – 150mW 100 – 150mW 100 – 150mW ?? mW
Frequenz 40kHz 40kHz 40kHz 40kHz 40kHz
Bereich 72º 55º 55º 55º 55º
Reichweite 4cm - 6m 3cm - 6m 3cm - 4m 3cm - 3m 15cm - 6m
Triggerimpuls

10µs min. 10µs min.
Abmessung in mm 32 x 15 x 10 43 x 20 x 17 43 x 20 x 17 43 x 20 x 17 24 x 20 x 17
Interface I2C I2C TTL Impuls TTL Impuls I2C o. RS232 TTL
Feature Minimodul Lichtsensor SRF04 Modus
nur 1 US-Kapsel
Preis ca. * 44,00 € 44,00 € 22,00 € 25,00 € 19,00 €

* Der Preis dient nur zum Vergleich untereinander, nicht als Referenz !

Kompaß

Kompass-Modul CMPS03

Laut der Doku ist diese Modul speziell für die Bedürfnisse von Robotern gestaltet worden. Es misst seine Lage relativ zum Erdmagnetfeld und liefert diesen Wert

  • Als PWM-Signal
  • Über I2C entweder 0-255 als Byte oder
  • 0-3599 als 16-Bit Wert (MSB first)

In der vorliegenden Doku ist eine fixe I2C-Adresse von 0xC0 angegeben. Was leider noch fehlt, sind Angaben, ob und wie diese Adresse geändert werden kann.

Bei waagrechter(!) Montage ist das also ein Kompass, bei senkrechter Montage dieser Module kann man auch die Neigung in Nord-Süd-Richtung messen. Hierzu sind 2 Module nötig, die zueinander um 90° gedreht angeordnet sein müssen. Die Neigung in Ost-West-Richtung zu messen, ist dagegen leider nicht möglich. Wenn ein CMPS03 als Kompass verwendet werden soll, sind zwei Dinge zu beachten:

  • Mindestens 20 cm Abstand von Eisen (Motoren)
  • Exakte horizontale Ausrichtung.

Eine Montage an einem langen Stab aus Holz oder Kunststoff hoch über dem Roboter ist sinnvoll.

Das Ganze ist eine Anwendung des Philips-KMZ51 Magnet-Feld-Sensors mittels eines PIC16F872

Gelegentlich sollte das Modul kalibriert werden. Das kann über den I2C-Bus, aber auch mittels einen Pins am Modul initiiert werden. Dafür muss am Pin 6 für jede Himmelsrichtung einmal kurz GND angelegt werden. Diese 4 Messpunkte nimmt das Modul auf und speichert sie im EEPROM.

Ein Beispielprogramm findet man hier:


Cmps3pin.jpg

CMPS09

Inzwischen ist der Nachfolger des CMPS03, nämlich der CMPS09 erhältlich.

Das Kompassmodul verfügt nun über eine Tilt-Kompensierung und ist im Vergleich zum CMPS03 deutlich kleiner. Die Auswertung geschieht, wie beim CMPS03 auch, über einen PWM-Ausgang oder den I2C-Bus, zudem ist hier noch eine serielle Schnittstelle (UART) mit 9600N2 vorhanden. Das Kompassmodul läuft bereits ab 3,3V.

Das Modul kann z.B. über robotikhardware.de bezogen werden.

Beschleunigung

Beschleunigungssensoren messen die Beschleunigung, die auf sie wirkt - wenn sie auf dem Tisch liegen, messen sie beispielsweise die Erdbeschleunigung von 1g. In einem Auto können weitere Beschleunigungen hinzukommen: Zur Seite beim Kurvenfahren, nach vorne oder hinten beim Beschleunigen, oder bei zügiger Fahrt über eine Bergkuppe auch mal welche in vertikaler Richtung.
Beschleunigungssensoren sind meist mehrdimensional ausgelegt, so dass für mehrere Achsen ein Sensor verwendet werden kann.

Beschleunigungssensor rh.gif

Anwendungen finden sie in ESP-Systemen in Autos, die u.a. über die Querbeschleunigung ausrechnen können, ob das Fahrzeug seitlich driftet oder gar schleudert.
Eine andere wichtige Aufgabe übernehmen sie zusammen mit Gyroskopen in Trägheitsnavigationssystemen, die dann sowohl die Lage im Raum als auch die Bewegung feststellen können.

Moderne Piezo-Sensoren sind nur noch chip-gross und können direkt in Schaltungen integriert werden.


Beispiele für solche Chips ist die Chipfamilie ADXL von Analog Devices. Sie umfaßt 1- und 2-Achs Accelerometer in verschiedenen Empfindlichkeiten. Der Test eines solchen Sensors ist hier beschrieben. http://www.roboternetz.de/phpBB2/viewtopic.php?t=8525

siehe auch: Sensoren - Beschleunigung

Drehung

Um Drehungen zu messen, werden sogenannte Gyroskope, kurz "Gyros" verwendet. Typische Vertreter sind hier die ADXRS-Familie von Analog Devices. Diese sind allerdings, anders als die Beschleunigungssensoren, meistens nur für eine Achse ausgelegt. Die Ausgabe erfolgt meist analog, jede Ausgangsspannung entspricht einer bestimmten Drehrate in °/Sekunde.

Gemessen wird die Auswirkung der Corioliskraft auf zwei gleiche, in Bewegung gehaltene Massen. Diese schwingen radial, d.h. 90° verdreht zu der Achse, auf der die Drehung gemessen werden soll. Wird der Sensor um die Achse gedreht, ändert sich die Geschwindigkeit dieser Massen, da sie auf einer gedachten Scheibe abwechselnd nach innen und außen wandern. Je weiter sie außen sind, desto höher ist ihre Geschwindigkeit, je weiter innen, desto langsamer sind sie. Bei der Bewegung nach außen müssen sie also beschleunigt werden, andersherum genauso. Die dabei auftretenden Beschleunigungen werden mittels einiger Fühler gemessen, die einen Plattenkondensator bilden.

Eine Anwendung sind im Flugmodellbau Gyro-"Taillocks", die in Hubschraubern die Heckstabilität verbessern und ESP-Systeme in Autos, die u.a. durch die Messung der Gierrate, also der Drehung des Fahrzeugs um die Hochachse, feststellen können, ob das Fahrzeug seitlich driftet oder sogar schleudert.

Geschwindigkeit

Geschwindigkeit kann unterschiedlich erfasst werden.

  • Direkt am Rad oder Antrieb. Diese Methode wird häufig auch in Kfz verwendet, stößt jedoch an ihre Grenzen, wenn die Räder viel Schlupf haben.
  • Gegenüber der Luft mittels Pitot-Tube. Das wird bei Flugzeugen so gemacht, oder z.B. in der Formel 1. Bei niedrigen Geschwindigkeiten nicht zu gebrauchen
  • Mittels eines optischen Sensors gegenüber dem Untergrund. Dafür kann ein Maussensor aus einer optischen Maus verwendent werden, evtl. mit einer Anpassung der Optik für einen geänderten Abstand.
  • Mittels GPS-Empfang. Funktioniert nur unter freiem Himmel.

Siehe auch unter Sensoren für die Geschwindigkeitsmessung

Temperatur

NTCs und PTCs

siehe PTC/NTC


KTY: Silizium Temperatursensoren

Die KTY-Temperatursensoren sind verglichen mit anderen Temperatursensoren verhältnismäßig günstig, haben dafür aber auch mehr Nachteile.
Die Genauigkeit ist ziemlich eingeschränkt, weshalb die KTY-Temperatursensoren zuerst kalibriert werden sollten. Dies kann schaltungstechnisch oder in Software erfolgen. Andererseits lassen sich mittels Oversampling sehr hoch aufgelöst Temperaturen messen, was aufgrund mittelmäßiger Linearität (auch nach der Linearisierung) aber nur bei der Messung kleiner Temperaturunterschiede empfehlenswert ist.
Linearisiert werden die KTY mit einem Reihenwiderstand von etwa 2,7 kOhm bis 3,3 kOhm als Spannungsteiler. Bei 5 V führt dies aber schon zu einer merklichen Eigenerwärmung. Im Vergleich zu, PT1000 ist der Temperaturkoeffizient beim KTY etwa doppelt so hoch - man bekommt also etwa das doppelte Signal. http://www.roboternetz.de/phpBB2/viewtopic.php?p=342164&sid=ad63fd51eb08bcf225389af5bbc4fcfd#342164

Diode als Temperatursensor

Die Flußspannung von Dioden ist temperaturabhängig. Für Siliziumdioden verringert sich die Spannung um etwa 2 mV pro Grad Temperaturerhöhung. Der Absolutwert der Flußspannung hängt etwas vom Strom ab und variiert auch zwischen verschiedenen Chargen. Es ist also fast immer wenigstens ein Abgleich nötig. Es kann auch eine Diodenstrecke eines Transistors genutzt werden, für eine ggf. besser geeignete Gehäuseform (z.B. BD135 im TO126 Gehäuse mit Bohrung).

LM335 und LM35

LM335.JPG

Der Temperatursensor LM335 funktioniert wie eine Z-Diode, die ihre Durchbruchspannung proportional zur Temperatur ändert. Beim Sensor LM335 beträgt diese Änderung 10mV/K, beim Sensor LM35 beträgt die Änderung 10mV/oC.

Der größte Unterschied zwischen den Sensoren ist der, dass am Ausgang des LM335 bei 0oC etwa 2,73V anliegen (273K = 0oC) und beim LM35 0V. Sollen negative Temperaturen gemessen werden, so muss man für den LM35 das Bezugspotential GND anheben (z.B. mit zwei Si-Dioden).

Von den Sensoren LM335 und LM35 gibt es auch noch genauere Ausführungen, welche einen geringeren Temperatur-Fehler ab Werk haben. Diese Versionen heißen LM15/LM25 bzw. LM135/LM235 und sind entsprechend teurer als die 3er Version (zum Vergleich: LM335 kostet bei Reichelt 0,89€, der LM135 jedoch 7,75€).

Der LM335 und LM35 messen nach einer einfachen Kalibrierung mit einem Poti, bis auf 1oC genau. Dazu muss man mit dem Poti die Ausgangsspannung bei 25oC auf 2,98V einstellen (2,98V / 0,01V/K = 298K = 25oC). Da der Sensor über seinen Messbereich sehr linear ist, braucht man nur bei einer Temperatur kalibrieren. Durch den Einsatz mehrerer in Reihe geschalteter Sensoren kann man das Ausgangssignal verstärken (bei drei LM335 erhält man dann 30mV/K anstatt 10mV/K) oder, wenn die Sensoren im Raum verteilt sind, einen einfachen Mittelwert bilden.

Beschaltung und Dimensionierung eines LM335

Lm335schaltung.jpg

Da sich der Sensor wie eine Z-Diode verhält, muss der Strom durch diese begrenzt werden, um eine Verfälschung des Signals oder gar eine Zerstörung zu verhindern. Fließt jedoch zu wenig Strom durch die Diode, so treten Störungen auf und die Genauigkeit sinkt.

Der Strom wird auf einfache Weise wie bei einer LED durch einen Widerstand (hier R1) begrenzt. Der Strom sollte zwischen mindestens 450µA und maximal 5mA liegen. Bei einer Betriebsspannung von 5V kann also für 2mA ein Widerstand von etwa 2,5kOhm benutzt werden (R = U/I).

Die max. Betriebsspannung sollte 30V nicht überschreiten!

Zur Kalibrierung schließt man an ein 10kOhm Potentiometer zwischen V+ und V- (GND) des Sensors an und legt dessen Schleifer auf den ADJ-Pin. Nun stellt man die Ausgangsspannung in Abhängigkeit von der Raumtemperatur (welche bekannt sein sollte) ein (1oC = 1K, 273K = 0oC). Kalibriert man den LM335 nicht, so kann dieser um bis zu 9K falsch gehen!

Im letzten Bild (ganz rechts) ist die schon angesprochene Reihenschaltung aufgezeichnet. Um ein größeres Ausgangssignal zu erhalten, kann man das Signal auch mit einem Operationsverstärker verstärken. Das ist günstiger und man hat die Möglichkeit, das Signal um ein Vielfaches zu verstärken ohne einige Dutzend Sensoren einzusetzen!

Pin-Belegungen und weitere Daten finden sich im Datenblatt (kann man z.B. bei Reichelt herunterladen).

Temperatur-Sensor LM75

Lm75.gif

Dieser Chip von National Semiconductors kann die Umgebungstemperatur mit einer Auflösung von 0.5o Grad Celsius messen und wird über einen I2C Bus angesprochen.

Der Messbereich:

  • −25oC bis 100oC bei ±2oC(max)Genauigkeit.
  • −55oC bis 125oC bei ±3oC(max)Genauigkeit.

Der LM75 bietet:

  • Einen Schaltausgang (invertierbar) - z.B. für Ventilator, Heizung etc.
  • Programmierbarer oberer und unterer Schaltpunkt.
  • Schaltausgang alternativ auch als Interrupt verwendbar.
  • Über von außen einstellbare I2C-Adresse. Bit 0 = R/W, Bits 1-3 einstellbar, Bit 4-7 fixe Adresse 0x9n
  • Maximal 8 Stück LM75 an einem I2C Bus.

Durch I2C-Lesebefehle kann man die Temperatur (2x8Bit)auslesen.

Das erste Byte ist der Temperatur-Vorkommawert in ganzen Grad, als normales signed char. Das Bit 7 vom zweiten Byte bestimmt den Nachkommawert. Wenn Bit 7 gleich 1 so ist der Nachkommawert + 0.5oC. Auch dann + 0.5 oC wenn Vorkommawert negativ. Wenn Bit 7 gleich 0 so ist der Nachkommawert = 0. Bit 0-6 vom zweiten Byte sind ohne Bedeutung.

Programm-Beispiel für LM75

Der LM75 wird über den I2C-Bus angesprochen. In BasCom, wo es ja keine signed char gibt, wird das Interpretieren auf sehr unterschiedliche Art empfohlen.

Ich empfehle:

dim Ival as integer
dim Msb as byte
dim Lsb as byte
        I2cstart
        I2cwbyte &H91   ' Lese-adresse !  
        If Err = 1 Then
           I2cstop       ' kein ACK vom LM75 --> irgendein Fehler
           Ival = 9999   ' Zeichen, daß der Wert ungültig ist !
        Else
           I2crbyte Msb , Ack
           I2crbyte Lsb , Nack
           I2cstop
           If Msb.7 = 1 Then
              Ival = Makeint(msb , &HFF)   ' auffüllen mit den Vorzeichen bits
           Else
              Ival = Makeint(msb , &H00)   ' positiv, also bleibt es so
           End If
           Ival = Ival * 10                ' erweitern 
           If Lsb.7 = 1 Then
             Ival = Ival + 5               ' fünf Zehntel Grad dazu 
           End If
        End if

Man erhält als Ergebnis die Temperatur in 0,5 Grad Schritten (Natürlich nur, wenn's keine Fehler gab).

Ein weiteres Beispiel [1]

Resistive Sensoren

Resistive Sensoren bzw. Linearpotentiometer arbeiten als Spannungsteiler über einer Hybridleitplastik- schicht und sind in unterschiedlichen Bauformen erhältlich; z.B. für Zylindereinbau, Klemmbock- u. Gelenkaugenbefestigung oder Taster. Deren Einsatzgebiete sind vorwiegend in der Industrie.

Kapazitive Sensoren

Ein Beispiel für kapazitive Sensoren sind Luftfeuchtigkeitsmesser, die ihre Kapazität entsprechend der Luftfeuchtigkeit ändern. Das Auslesen der Kapazität kann prinzipiell über das Ausmessen von Ladekurven geschehen. Dies ist jedoch bei kleinen Kapazitäten nicht praktisch durchführbar, weshalb man in diesem Falle meist einen Schwingkreis baut, dessen Frequenz man dann misst und so dann zusammen mit der bekannten Induktivität der Spule die Kapazität des Kondensators ausrechnen kann.


Valvo Feuchtigkeitssensor 10-90% (Kapazität: 122 pF bei TU = 25 °)

Induktive Sensoren

Sensoren die ihre Induktivität entsprechend der Messgröße ändern können auch mit Hilfe eines Schwingkreises mit bekannter Kapazität ausgemessen werden.

Induktiver Näherungsschalter enthalten schon eine Elektronik zur Auswertung und liefern meist ein digitales Signal. Die Funktion ist ähnlich den einfachen Metallsuchgeräten: Der Sensor spricht an, wenn im Abstand von weniger als z.B. 2 cm Metall vor dem Sensor ist.

Piezoelektrische Sensoren

Hier ist ein Experiment dargestellt das die Funktion von Piezowandlern demonstriert.

Drückt man auf eine längliche Glasplatte (Mikroskopträger Länge 76mm), die an den Enden auf je einem Piezo Wandler gelagert ist, dann ergeben sich Signale, die von den Kräften auf die Wandler abhängig sind.

Die Summe der beiden Kräfte entspricht der Gesamtkraft. Das Verhältnis der beiden Kräfte entspricht dem Verhältnis der Abstände des Druckpunktes zum Wandler.


Piezowandler.jpg


Im Versuch wurde mit der Frequenz von ca. 4Hz (0,5s/div) von einem Ende bis zum anderen auf die Platte gedrückt. (Tonleiter). Die Signale der beiden Wandler sind im Oszillogramm aufgetragen und die Folge der Druck-Positionen ist auf den ersten Blick schon mal nachvollziehbar.

PIR Passiv Infrarot Sensoren

Hier handelt es sich um Passiv-Infrarot-Bewegungsmelder. Bewegungsmelder regieren beim Eintritt einer Person (Tier) in das Erfassungsfeld des Sensors. Die Anwendungsmöglichkeiten sind nahezu unbegrenzt, man kennt die Technik ja von vielen Terrassenlampen, welche sich beim vorbeigehen automatisch einschalten. Reagiert wird also auf die Körperwärme einer sich im Erfassungsfeld bewegenden Person.

Pir.jpg

Zum Prinzip: Wärmestrahlen, die einen Erfassungsvorgang auslösen, liegen im Infrarot-Bereich des Wellenspektrums. In diesem Bereich gibt der menschliche Körper seine Wärmestrahlung ab. Leuchtmittel wie Glüh- , Halogen- und Entladungslampen, die für eine Strahlung im sichtbaren Bereich um 0,555 μm entwickelt wurden, geben jedoch auch einen erheblichen Teil an Wärmestrahlung im Infrarot-Bereich ab. Im Spektrum oberhalb des sichtbaren Licht, ab 0,780 μm, beginnt der Infrarot-Bereich. Die Wellenlänge dieser IR-Strahlung ist abhängig von der Temperatur eines Körpers. Die Wärmestrahlung des Menschen hat ihr Maximum zwischen 9 und 10 μm im Infrarot-Bereich. Diese Tatsache nutzt der PIR Sensor mittels sogenannter pyroelektrischer IRDetektoren, welche eine hohe Empfindlichkeit im langwelligen Infrarot-Bereich aufweisen. Die Infrarot- Strahlung verhält sich ähnlich wie sichtbares Licht. Sie kann reflektiert und durch Linsen gebündelt werden. Basis eines solchen IR-Detektors (Sensors) sind Lithium-Tantalatkristalle. Diese Kristalle erzeugen, bei Wärmeänderung (positive oder negative Temperaturänderung), eine elektrische Spannung. Die von den Kristallen abgegebene Spannung liegt im Bereich von einigen μV (μV = millionstel Volt) und ist von folgenden Bedingungen abhängig:

  • Der Intensität der Wärmequelle (Temperatur und Größe)
  • Dem Umgebungsmedium (Temperatur, unterschiedliche Luftfeuchtigkeit)
  • Der Entfernung zwischen Wärmequelle und IR-Sensor
  • Der Bewegungsgeschwindigkeit und Bewegungsrichtung der Wärmequelle
  • Der Empfindlichkeit des PIR-Elementes (frequenzabhängiges Bandpaßverhalten mit Maximum bei ca. 0,1 Hz)

Zur Unterdrückung von Einflüssen aus der Umgebung (übliche wetterbedingte Temperaturänderungen), sind in jedem Sensor 2 Kristalle antiparallel geschaltet. Einer der Kristalle gibt, bei Auftreffen von Wärmestrahlung einen positiven, der andere einen negativen Spannungsimpuls ab. Wärmeänderungen die gleichzeitig und mit gleicher Intensität auf beide Kristalle einwirken lösen so keinen Erfassungsvorgang aus, denn die beiden Impulse heben sich gegenseitig auf. Dadurch ist ein Auslösen bei Wärmeänderungen der Umgebung weitgehend ausgeschlossen. Anders verhält es sich bei schnellen Bewegungen. Die Lithiumtantalat-Kristalle geben, entsprechend der Bewegung und der dadurch hervorgerufenen Wärmeänderung im Erfassungsfeld, ihre Impulse zeitversetzt ab. Die beiden Impulse addieren sich zu einer Wechselgröße mit höherer Signalamplitude. Dieses elektrische Ausgangssignal ist proportional der Wärmeänderung und führt zur Meldung einer Bewegung.

Infrarot Thermopiles

Bei den Infrarotsensoren gibt es neben den oben beschrieben PIR Sensoren aus Bewegungsmeldern auch solche auf Basis von Thermopiles. Diese können nicht nur auf Änderungen reagieren, sondern auch eine konstante Strahlung messen. Beispiele ist der TPS334. Der Sensor gibt eine relativ kleine Spannung (oft < 0,1 mV) aus, die in der Regel erst verstärkt werden muss. Neben dem eigentlichen Strahlungssensor gibt es noch eine Möglichkeit die Temperatur des Sensors selbst zu messen, um die Abstrahlung des Sensor zu kompensieren.

Zu finden sind solche Sensoren z.B. in Infrarotthermometern.

Autoren

Siehe auch

Weblinks



Quelle:
http://rn-wissen.de/wiki/index.php?title=Sensorarten



DIN A4 ausdrucken
*********************************************************

Impressum: Fritz Prenninger, Haidestr. 11A, A-4600 Wels, Ober-Österreich, mailto:schaltungen@schaltungen.at
ENDE





Comments