http://sites.schaltungen.at/arduino-uno-r3/arduino---sensoren/sensoren
Wels, am 2016-11-18BITTE nützen Sie doch rechts OBEN das Suchfeld [ ] [ Diese Site durchsuchen]DIN A3 oder DIN A4 quer ausdrucken
*******************************************************************************I** DIN A4 ausdrucken
********************************************************I*
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
|
Anhang1: FiberOpticalCurrentSens | [ ] |
|
Anhang2: SENSOR_CONF_fiber_optic_current_sensor | [ ] |
|
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 Receiverhttps://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
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.pdfhttp://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
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
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);
}
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);
}
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.
Datenblatt: MS5611-01BA01.pdf
http://www.daedalus.ei.tum.de/index.php/de/archiv/material/sensoren/luftdrucksensor-ms5611
15. Kompass Modul HMC5883L
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:[email protected]">[email protected]</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/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.pdfhttp://www.daedalus.ei.tum.de/index.php/de/archiv/material/sensoren/beschleunigungssensor-adxl345
*********************************************************
Sensorarten
Inhaltsverzeichnis
- 1 Welche Sensorarten gibt es
- 2 Bumpers
- 3 Whiskers (Fühler)
- 4 Magnetische Sensoren
- 5 Optische Sensoren
- 6 Ultraschall Sensoren
- 7 Kompaß
- 8 Beschleunigung
- 9 Drehung
- 10 Geschwindigkeit
- 11 Temperatur
- 12 Resistive Sensoren
- 13 Kapazitive Sensoren
- 14 Induktive Sensoren
- 15 Piezoelektrische Sensoren
- 16 PIR Passiv Infrarot Sensoren
- 17 Infrarot Thermopiles
- 18 Autoren
- 19 Siehe auch
- 20 Weblinks
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.
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.
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
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.
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 |
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
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
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.
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
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 HzPhotodarlington-Transistor ca. 30 kHzPhoto-Transistor ca. 300 kHzPhoto-Diode ca. 10 MHzPhoto-Pin-Diode ca. 1 GHz
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.
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.
Der normale Schaltungsaufbau sieht also wie oben abgebildet aus! In der Praxis kann das dann in etwa so aussehen:
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.
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.
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:
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! |
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 RoboternetzUntersuchung 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.
Sharp GP2Y0A21YK0F (Nachfolger des GP2D12)
Distanz 10-80 cm - Entfernung wird durch analoge Spannung am Ausgang übermittelt.
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.
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
GPD120 Messkurve
Messfleckgröße des SHARP GP2Y0A41SK0F
siehe
Drehgeber Sharp GP1A30 und GP1A38
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
- Überlegungen zur Drehgeber-Auswertung
- Beispiel Drehzahlmessung mit RN-Control
- Beispiel Drehzahlmessung mit Drehgeber
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:
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.
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
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 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 AdresseConst Sf08_c_range = 100 ' ReichweiteConst 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.
SetupNach 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.
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
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
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:
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.
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
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
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
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 integerdim Msb as bytedim 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.
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.
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.
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ängedieser IR-Strahlung ist abhängig von der Temperatur eines Körpers. Die Wärmestrahlungdes 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 Linsengebü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, entsprechendder Bewegung und der dadurch hervorgerufenen Wärmeänderung im Erfassungsfeld, ihreImpulse zeitversetzt ab. Die beiden Impulse addieren sich zu einer Wechselgröße mit höhererSignalamplitude. 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
- Navigation
- Sensoren
- Graycode
- Ultraschall SRF10 an RN-Control
- Ultraschall SRF05 an RN-MiniControl
- Ultraschallsensor SRF02 am RN-Board
- Bascom und Kompass CMPS03
- Bascom und Kompass LSM303DLH
Weblinks
- Aktuelle Sensorvorstellungen und Datenblätter unter Mikrocontroller-Elektronik.de
- Forumbeitrag: Drehzahlmessung bei Gleichstrommotoren über Bürstenimpulsauswertung
- Piezoelektrische Sensoren
- KTY Sensor Datenblatt
- NTC Datenblatt
- Technische Daten, Links zum Hersteller für diverse CMP und SRF Sensoren sowie Adaptermodule
- Technische Daten von zahlreichen Sensoren
- Übersicht elektromagnetische, mechanische und akustische Sensoren
- Preiswerter Ultraschallsensor HC-SR04
Quelle:
http://rn-wissen.de/wiki/index.php?title=Sensorarten
DIN A4 ausdrucken
*********************************************************
Impressum: Fritz Prenninger, Haidestr. 11A, A-4600 Wels, Ober-Österreich, mailto:[email protected]
ENDE