http://sites.schaltungen.at/arduino-uno-r3/theorycircuit/sketch-4

http://www.linksammlung.info/

http://www.schaltungen.at/

                                                                                            Wels, am 2016-11-11

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

DIN A3 oder DIN A4 quer ausdrucken
*********************************************************************************************
DIN A4  ausdrucken  (Heftrand 15mm / 5mm)

Untergeordnete Seiten (6):
Sketch-5

40) Home > Arduino Projects > Serial Communication with Arduino
4x LED mit 220R Serielle-Steuerung (pin-9, 10, 11, 12)  -  Serial

Serielle Kommunikation mit Arduino

Hier zeigt dieses Projekt, wie man mit dem seriellen Terminal von arduino kommuniziert?
Für eine Anwendung haben wir vier LEDs zur Richtungsangabe gewählt.

In einem Brotbrett werden vier LED in der unterschiedlichen Richtung gelegt und die Arduino Skizze, die zusammengebaut wird, um diese LED mit Computer numerischen Schlüssel zu kontrollieren, indem sie eine bestimmte Taste drücken, die wir Ausgabe erhalten können.


Serielle Kommunikation-ARDUINO UNO R3

Schaltplan


Dieser Arduino-Code kann geändert werden, um die gewünschte Eingabe und Ausgabe zu erhalten.

Arduino serielle Kommunikation Sketch / Code

//theorycircuit.com
//Serial communication to arduino board through key board to control direction Indicators

const int right = 12;
const int left = 9;
const int top = 10;
const int bottom = 11;
char data;

void setup() {
Serial.begin(9600);
pinMode(right,OUTPUT);
pinMode(left,OUTPUT);
pinMode(top,OUTPUT);
pinMode(bottom,OUTPUT);
}

void loop() {
if(Serial.available()>0)
{
data=Serial.read();
if(data=='1') {
digitalWrite(left,HIGH);
digitalWrite(right,LOW);
digitalWrite(top,LOW);
digitalWrite(bottom,LOW);
Serial.println("Left Indicator activated");
}
else if(data=='2') {
digitalWrite(left,LOW);
digitalWrite(right,LOW);
digitalWrite(top,HIGH);
digitalWrite(bottom,LOW);
Serial.println("Top Indicator activated");
}
else if(data=='3') {
digitalWrite(left,LOW);
digitalWrite(right,LOW);
digitalWrite(top,LOW);
digitalWrite(bottom,HIGH);
Serial.println("Bottom Indicator activated");
}
else if(data=='4') {
digitalWrite(left,LOW);
digitalWrite(right,HIGH);
digitalWrite(top,LOW);
digitalWrite(bottom,LOW);
Serial.println("Right Indicator activated");
}
}
}

http://www.theorycircuit.com/serial-communication-with-arduino/

41) Home > Arduino Projects > Tilt Switch arduino schematics
AT407 Kippschalter (pin-2)  -  LED (pin-13)

Neigungssensor / Kippschalter / Quecksilberschalter ARDUINO UNO R3

http://www.instructables.com/id/Tilt-Sensor-Tutorial/
arn.adafruit.com/tilt-sensor/overview

Beschreibung:
Dieser AT407 grundlegende Neigungsschalter kann leicht verwendet werden, um die Orientierung zu erkennen. Innerhalb der Dose ist eine Kugel, die Kontakt mit den Stiften, wenn das Gehäuse aufrecht ist. Kippen Sie das Gehäuse um, und die Kugeln berühren sich nicht, so dass keine Verbindung hergestellt wird.

Es gibt zahlreiche Verwendungen für diese grundlegenden Sensoren, aber denken Sie daran, müssen Sie einige Entprellung Code verwenden, da der Sensor nicht immun gegen kleine Vibrationen und so ist.
SparkFun  Tilt Sensor - AT407    SEN-10289

Neigungssensor Print 1 Schließer, 1 Öffner

Tilt Sensor / Tilt Switch / Tilt switch sensor
https://www.arduino.cc/en/Tutorial/TiltSensor
https://www.arduino.cc/en/Tutorial/Button
https://learn.adafruit.com/tilt-sensor/using-a-tilt-sensor
https://learn.adafruit.com/tilt-sensor
http://www.instructables.com/id/Tilt-Sensor-Tutorial/
http://www.electroschematics.com/12124/arduino-tilt-sensor-experiment/
http://www.electroschematics.com/12124/arduino-tilt-sensor-experiment/
http://www.electronicshub.org/arduino-tilt-sensor/
http://garagelab.com/profiles/blogs/tutorial-tilt-sensor-with-arduino
http://henrysbench.capnfatz.com/henrys-bench/arduino-sensors-and-input/keyes-ky-017-arduino-mercury-tilt-switch-tutorial/
http://funduino.de/nr-09-arduino-neigungssensor


Tilt switch sensor module SW520D  SW-520D

Neigungssensor-modul Tilt Switch Winkel sensor Modul Ball Schalter Dumping Sensor

Arduino KY-020 Tilt switch module

Tilt Switch Module Angle Sensor Module for Arduino SW520D

Tilt Switch Modul Winkel Sensor Modul für Arduino SW520D

https://de.aliexpress.com/item/1pcs-lot-Tilt-Switch-Module-Angle-Sensor-Module-for-Arduino-SW520D-Free-Shipping/32753355271.html


Der kleine preiswerte einfach zu bedienende Sensor, ermöglicht es Ihnen, Orientierung oder Neigung zu erkennen.
Durch den Anschluss dieses Neigungssensors mit arduino können wir LED, Summer oder andere Ausgangsgeräte steuern.

Hier verbinden wir den Neigungssensor mit Arduino-Platine und LED als Ausgangsindikator.
Achten Sie darauf, einen 10kΩ-Vorwiderstand zwischen Masse (GND) und einem Anschluss des Neigungssensors anzuschließen,
der mit dem arduino-Digitaleingang verbunden ist.

TiltSwitch-Sensor-Arduino

Schaltplan

TiltSwitch-Schaltung

In diesem Sensor zwei leitende Pole platziert und die Massenrolle zwischen diesen beiden Polelementen platziert.
Wenn sich die Ausrichtung des Sensors nach unten ändert, kürzt die Massenrolle die beiden Pole und wirkt als Schaltwurf.

Arduino Tilt Schalter Sensor Sketch / Code:

/*www.theorycircuit.com*/
int SensorPin = 2;
int LEDPin = 13;

int LEDstate = HIGH;
int reading;
int previous = LOW;

long time = 0;
long debounce = 50;

void setup() {
pinMode(SensorPin, INPUT);
digitalWrite(SensorPin, HIGH);
pinMode(LEDPin, OUTPUT);
}

void loop() {
int switchstate;

reading = digitalRead(SensorPin);
if (reading != previous) {

time = millis();
}

if ((millis() - time) > debounce) {

switchstate = reading;

if (switchstate == HIGH)
LEDstate = LOW;
else
LEDstate = HIGH;
}
digitalWrite(LEDPin, LEDstate);

previous = reading;
}

http://www.theorycircuit.com/tilt-switch-arduino-schematics/

42) Home > Arduino Projects > Interfacing 4×4 Keypad with Arduino
Keypad 4x4 Matrix (pin-2, 3, 4, 5, 6, 7, 8, 9, )  -  Serial

Schnittstellen 4 × 4 Tastenfeld mit ARDUINO UNO R3

Viele Projekte benötigen Tasten, die gemeinsame 4×4 Tastatur hat 16-Tasten (Hex-Eingang).
Um diese Tastatur zu konstruieren, benötigen Sie sechzehn Drucktasten und Fertigkeiten, um Zeilen und Spalten zwischen den Schaltern zu erzeugen.

Heutzutage können wir vorbereitet Tastaturen, in diesem Tastenfeld 8 weiblichen Stecker platziert, um Schnittstelle mit anderen Schaltungen,
pin-1 bis pin-4 sind Zeilen und pin-5 bis pin-8 sind Spalten.


http://playground.arduino.cc/Main/KeypadTutorial
http://www.instructables.com/id/interface-keypad-with-arduino/


4 x 4 Matrix Array 16 Key Membranschalter-Tastatur-Tastatur für Arduino AVR
Universial 16 Key 4 x 4 Matrix Array Switch Tastatur Keypad Keyboard Schlüsselschalter Modul für Arduino
4x4 Matrix Membrane Keypad ARDUINO
4x4 Universial 16 Schlüsselschalter Tastatur für Arduino
4x4 Universial 16 Key Switch Keypad Keyboard for Arduino


Keypad-ARDUINO

4 × 4 Tastaturbelegung



4x4-Tastatur-Matrix

In unserem Fall verbinden wir 4 x 4 Keypad mit arduino und den Skizzencode, um die gedrückte Taste von der Tastatur über den seriellen Monitor zu betrachten.

Arduino 4 × 4 Tastatur Sketch / Code:

/*4x4 Matrix Keypad connected to Arduino
www.theorycircuit.com
This code prints the key pressed on the keypad to the serial port
Get keypad library file from : http://playground.arduino.cc/Code/Keypad */
#include <Keypad.h>

const byte numRows= 4; //number of rows on the keypad
const byte numCols= 4; //number of columns on the keypad

//keymap defines the key pressed according to the row and columns just as appears on the keypad
char keymap[numRows][numCols]=
{
{'1', '2', '3', 'A'},
{'4', '5', '6', 'B'},
{'7', '8', '9', 'C'},
{'*', '0', '#', 'D'}
};

//Code that shows the the keypad connections to the arduino terminals
byte rowPins[numRows] = {9,8,7,6}; //Rows 0 to 3
byte colPins[numCols]= {5,4,3,2}; //Columns 0 to 3

//initializes an instance of the Keypad class
Keypad myKeypad= Keypad(makeKeymap(keymap), rowPins, colPins, numRows, numCols);

void setup() {
Serial.begin(9600);
}

//If key is pressed, this key is stored in 'keypressed' variable
//If key is not equal to 'NO_KEY', then this key is printed out
//if count=17, then count is reset back to 0 (this means no key is pressed during the whole keypad scan process


void loop() {
char keypressed = myKeypad.getKey();
if (keypressed != NO_KEY) {
Serial.print(keypressed);
}
}

http://www.theorycircuit.com/interfacing-4x4-keypad-arduino/

43) Home > Arduino Projects > Accelerometer sensor arduino schematics
ADXL335 3-Achsen Accelerometer Modul   (pin-A0, A1, A2, A3)  -  3xLED (pin-3, 7, 11)  - Taster (pin-2)  

3-Achsen Beschleunigungs-Sensor ARDUINO UNO R3

SparkFun Triple Axis Accelerometer Breakout - ADXL335 SEN-09269

SainSmart ADXL335 Triple Axis Accelerometer Breakout Module

https://www.sparkfun.com/products/9269
https://www.adafruit.com/product/163

Beschreibung: Breakout Board für die 3 Achsen ADXL335 von Analog Devices.
Dies ist die neueste in einer langen, bewährten Reihe von analogen Sensoren - dem heiligen Gral der Beschleunigungsmesser.
Der ADXL335 ist ein Dreifach-MEMS-Beschleunigungssensor mit extrem niedrigem Rauschen und Leistungsaufnahme - nur 320uA! Der Sensor hat einen vollen Messbereich von +/- 3g.

Es gibt keine On-Board-Regelung, vorausgesetzt, dass die Spannung zwischen 1,8 und 3,6 VDC liegen sollte.

Board wird komplett montiert und getestet mit externen Komponenten installiert.
Die mitgelieferten 0.1uF-Kondensatoren stellen die Bandbreite jeder Achse auf 50Hz ein.

Nicht sicher, welcher Beschleunigungsmesser für Sie das Richtige ist?
Unser Beschleunigungsmesser und Gyro Einkaufsführer könnte helfen!



Der Beschleunigungsmesser ist ein MEMS-Sensor, er misst die Beschleunigung in zwei verschiedenen Einheiten einschließlich Metern pro Sekunde Quadrat oder die Beschleunigung fühlte sich wie Gewicht, G-Kräfte.
Beschleunigungsmesser weit verbreitet für Orientierungserkennung verwendet.

Beschleunigungssensor-Arduino

ADXL Breakout Accelerometer Triple Axis Modul

220R (rt-rt-br-gd)   1,2k Ohm  (br-rt-rt-gd)

Schaltplan



Beschleunigungssensor-Sensor-Schaltung

Arduino Beschleunigungssensor Sketch Code:

/*www.theorycircuit.com*/
int myState=0;
int greenLedPin=11;
int redLedPin=7;
int blueLedPin=3;
int buttonPin=2;
int potPin=3;
int accZPin=0;
int accYPin=1;
int accXPin=2;

int startAccZ;
int startAccY;
int startAccX;

void setup()  {
pinMode(greenLedPin,OUTPUT);
pinMode(redLedPin,OUTPUT);
pinMode(blueLedPin,OUTPUT);
pinMode(buttonPin,INPUT);
startAccZ=analogRead(accZPin);
startAccY=analogRead(accYPin);
startAccX=analogRead(accXPin);
}

void alertBlinking()  {
digitalWrite(redLedPin,HIGH);
delay(50);
digitalWrite(redLedPin,LOW);
delay(100);
digitalWrite(blueLedPin,HIGH);
delay(50);
digitalWrite(blueLedPin,LOW);
delay(100);
}

boolean senseAcceleration(int myPotVal){
boolean myReturn=false;
myPotVal=map(myPotVal,0,1023,0,10);
if (analogRead(accXPin)>startAccX+myPotVal) myReturn=true;
if (analogRead(accYPin)>startAccY+myPotVal) myReturn=true;
if (analogRead(accZPin)>startAccZ+myPotVal) myReturn=true;
return myReturn;
}

void loop()  {
//alertBlinking();
switch (myState)  {
case 0: //idle
if (senseAcceleration(analogRead(potPin))==true) {
digitalWrite(greenLedPin,LOW);
myState=1;
} else  {
digitalWrite(greenLedPin,HIGH);
};
break;
case 1: // alert
alertBlinking();
if (digitalRead(buttonPin)==HIGH){
myState=0;
}
break;
}
delay(10);
}

http://www.theorycircuit.com/accelerometer-sensor-arduino-schematics/

44) Home > Arduino Projects > Gyroscope L3G4200D arduino schematic
L3G4200D Gyroscope-Modul  (pin-A4  SDA   pin-A5  SCL)  -  Serial

Gyroscope L3G4200D Sensor

SparkFun Tri-Axis Gyro Breakout - L3G4200D   SEN-10612  https://www.sparkfun.com/products/10612

ST  L3G4200D  MEMS motion sensor: ultra-stabile three-axis digital output gyroscope
http://www.st.com/content/ccc/resource/technical/document/datasheet/04/46/d6/00/be/d9/46/ae/CD00265057.pdf/files/CD00265057.pdf/jcr:content/translations/en.CD00265057.pdf

L3GD20 3-Axis Gyro Carrier with Voltage Regulator
https://www.pololu.com/product/2125


L3G4200D ist das Dreifach-Gyroskop eines der MEMS-Sensor, ist dieser Sensor preiswert und misst in Grad pro Sekunde oder Umdrehungen pro Sekunde die Winkelgeschwindigkeit.

Es wird vor allem in der Ausgleichslage Anwendung, Roboter-Anwendung, Dronen Stabilisierung usw. verwendet ...
die Schaltung hier ist es, die Sensor-Ausgang über serielle Schnittstelle zu messen.
Unter Verwendung der Bedingungsanweisung können wir jegliche elektronische Peripherie gemäß dem Wert des Gyroskopsensors steuern.
Zur Verwendung dieses Gyroscope L3G4200D-Sensors mit Arduino benötigen wir Bibliotheksdatei, erhalten L3G4200D Sensor-Bibliothek hier.

Gyroscope-L3G4200D-arduino

Schaltplan



Gyroscope-L3G4200D-Schaltung

https://github.com/pololu/l3g-arduino
Arduino Gyroscope L3G4200D arduino Sensor-Sketch / -Code:

/*www.theorycircuit.com*/

#include <Wire.h>

#define CTRL_REG1 0x20
#define CTRL_REG2 0x21
#define CTRL_REG3 0x22
#define CTRL_REG4 0x23
#define CTRL_REG5 0x24

int L3G4200D_Address = 105;                        //   I2C address of the L3G4200D

int x;
int y;
int z;

void setup()  {

Wire.begin();
Serial.begin(9600);

Serial.println("starting up L3G4200D");
setupL3G4200D(2000);                                      // Configure L3G4200 - 250, 500 or 2000 deg/sec

delay(1500);                                                            //wait for the sensor to be ready
}

void loop()  {
getGyroValues();                                                      // This will update x, y, and z with new values

Serial.print("X:");
Serial.print(x);

Serial.print(" Y:");
Serial.print(y);

Serial.print(" Z:");
Serial.println(z);

delay(100);                                                                  //Just here to slow down the serial to make it more readable
}

void getGyroValues()  {

byte xMSB = readRegister(L3G4200D_Address, 0x29);
byte xLSB = readRegister(L3G4200D_Address, 0x28);
x = ((xMSB << 8) | xLSB);

byte yMSB = readRegister(L3G4200D_Address, 0x2B);
byte yLSB = readRegister(L3G4200D_Address, 0x2A);
y = ((yMSB << 8) | yLSB);

byte zMSB = readRegister(L3G4200D_Address, 0x2D);
byte zLSB = readRegister(L3G4200D_Address, 0x2C);
z = ((zMSB << 8) | zLSB);
}

int setupL3G4200D(int scale)  {
                                                                                //From Jim Lindblom of Sparkfun's code

                                                                                // Enable x, y, z and turn off power down:
writeRegister(L3G4200D_Address, CTRL_REG1, 0b00001111);

                                                                                // If you'd like to adjust/use the HPF, you can edit the line below to configure CTRL_REG2:
writeRegister(L3G4200D_Address, CTRL_REG2, 0b00000000);

                                                                             // Configure CTRL_REG3 to generate data ready interrupt on INT2
                                                                             // No interrupts used on INT1, if you'd like to configure INT1
                                                                                // or INT2 otherwise, consult the datasheet:
writeRegister(L3G4200D_Address, CTRL_REG3, 0b00001000);

                                                                               // CTRL_REG4 controls the full-scale range, among other things:

if(scale == 250)  {
writeRegister(L3G4200D_Address, CTRL_REG4, 0b00000000);
}else if(scale == 500){
writeRegister(L3G4200D_Address, CTRL_REG4, 0b00010000);
}else{
writeRegister(L3G4200D_Address, CTRL_REG4, 0b00110000);
}

                                                                                // CTRL_REG5 controls high-pass filtering of outputs, use it
                                                                               // if you'd like:
writeRegister(L3G4200D_Address, CTRL_REG5, 0b00000000);
}

void writeRegister(int deviceAddress, byte address, byte val) {
Wire.beginTransmission(deviceAddress);         // start transmission to device
Wire.write(address);                                                // send register address
Wire.write(val);                                                           // send value to write
Wire.endTransmission();                                       // end transmission
}

int readRegister(int deviceAddress, byte address)  {

int v;
Wire.beginTransmission(deviceAddress);
Wire.write(address);                                          // register to read
Wire.endTransmission();

Wire.requestFrom(deviceAddress, 1);           // read a byte

while(!Wire.available())  {
                                                                               // waiting
}

v = Wire.read();
return v;
}

http://www.theorycircuit.com/gyroscope-l3g4200d-arduino-schematic/

45) Home > Arduino Projects > Proximity (GP2Y0A21YK ) distance Sensor with Arduino
GP2Y0A21YK IR-Abstands-Sensor  (pin-A0)  -  LEDs (pin-9, 10)   -  Serial

Sharp GP2Y0A21YK0F Analog Distance Sensor 10..80cm

Proximity (GP2Y0A21YK) Abstand Sensor mit Arduino
http://physicalcomputing.at/IR-Sensor-Sharp-GP2Y0A21YK
https://www.pololu.com/product/136

Infrared Proximity Sensor - SHARP GP2Y0A21YK SEN-00242  https://www.sparkfun.com/products/242
http://www.sharpsma.com/webfm_send/1208
Beschreibung:
Infrarot-Näherungsschalter von Sharp. Teil # GP2Y0A21YK hat einen analogen Ausgang, der von 3.1V bei 10cm zu 0.4V bei 80cm schwankt. Der Sensor verfügt über einen japanischen Solderless-Anschluss (JST). Wir empfehlen, das zugehörige Pigtail unten oder Lötdrähte direkt an der Rückseite des Moduls zu kaufen
SHARP Datenblatt GP2Y0A21YK
https://www.sparkfun.com/datasheets/Components/GP2Y0A21YK.pdf

Distance Measuring Sensor Unit Digital output
IR Distans-Sensor SHARP GP2Y0D810Z0F 2.. 10cm https://www.pololu.com/file/0J154/GP2Y0D810Z0F.pdf
IR Distans-Sensor SHARP GP2Y0A21YK0F 10 .. 80cm  http://www.sharpsma.com/webfm_send/1489

Der IR- (Infrarot-) Näherungssensor oder der Abstandssensor hat zwei Elemente, der eine ist der IR-Strahler und der andere der IR-Empfänger.
Wir verwenden GP2Y0A21YK Weitwinkel-Distanzmesssensor. Es wird 32-kHz-Bereich IR-Impuls und typische Antwortzeit des IR-Empfängers wird 39 ms produzieren.

Wenn es ein Objekt vor diesem Sensor (10 bis 80 cm) gibt, reflektiert dieses Objekt einige IR-Strahlen zurück zum IR-Empfänger, wie wir Objekte erkennen können.
Diese Schaltung hat zwei Ausgangspegel, die grüne und rote LED ist.
Wenn sich das Objekt in die Nähe des Sensors bewegt, leuchtet die rote LED, sonst leuchtet die grüne LED, wenn das Objekt vom Sensor erkannt wird.
Um diesen IR-Distanzsensor mit arduino zu verwenden, benötigen wir die Bibliotheksdatei, erhalten hier die GP2Y0A21YK Sensor Library.

Proximity-Sensor-Arduino UNO R3

GP2Y0A21YK Sensor

Widerstand 220R

LEDgn   LEDrt

Schaltplan

Proximity-Sensor-Schaltung

Das IR-Licht ist mit bloßem Auge nicht sichtbar. Sie können es durch mobile Kamera oder Digitalkamera zu sehen.

https://github.com/jeroendoggen/Arduino-GP2Y0A21YK-library
Arduino Proximity (GP2Y0A21YK) Entfernung Sensor Sketch / Code:

/*www.theorycircuit.com*/

#include <DistanceGP2Y0A21YK.h>

int ledGreen = 9;
int ledRed = 10;
int proximity = 0;

void setup(){

Serial.begin(9600);
}

void loop () {
int value = analogRead(proximity);
Serial.println(value);
int redValue = map(value,0,1023,0,255);
int greenValue = map(value,0,1023,255,0);
analogWrite(ledRed,redValue);
analogWrite(ledGreen,greenValue);

delay(100);

}

http://www.theorycircuit.com/proximity-gp2y0a21yk-distance-sensor-with-arduino/

46) Home > Arduino Projects > Photocell (LDR) Sensor with Arduino
LDR05 10k Dämmerungs-Schalter  (pin-A2)  -  LED (pin-11)   -  Serial

Dämmerungsschalter / Helligkeitsschalter / Lichtschranke (LDR) mit Arduino

LDR (Lichtabhängiger Widerstand) oder Lichtschranken-Sensor, wenn das Licht auf diesen Sensor Widerstand über das Gerät fällt gering, wenn die Lichtintensität sinkt der Widerstand der Photozelle erhöht.

Durch die Verwendung dieses Sensors können wir den Lichtintensitäts- oder Kontrolllicht-Alarmkreis messen.
Um die einfache Bedienung dieser Lichtschranke zu verstehen, ist sie mit der Arduino-Platine verbunden, so dass wir den Sensorwert im seriellen Port und die Ausgangs-LED-Intensität entsprechend dem Sensorwert empfangen können.

Lichtschranke  Arduino UNO Rev.3

Schaltplan

Lichtschrankenschaltung

Arduino Lichtschranke (LDR) Sensor-Sketch / Code:

/*www.theorycircuit.com*/
int ledPin = 3;
int photocell = 0;

void setup() {
pinMode(ledPin, OUTPUT);
Serial.begin(9600);
}

void loop() {
photocell = (analogRead(0)/4);  // Divides input 0-1023 to resemble to 0-255

analogWrite(ledPin, photocell);
Serial.print(photocell);
                                                            // The delay can be change to get the desired dimming effect
delay(20);                                          // Pause 20ms
}

http://www.theorycircuit.com/photocell-ldr-sensor-with-arduino/

47) Home > Arduino Projects > Flex Sensor with Arduino
SEN-10264 Flex-Sensor 10k  (pin-A0)  -  LED mit Rv 220R (pin-9)   -  Serial

Flex-Sensor mit Arduino

SparkFun Flex Sensor 2.2" SEN-10264     https://www.sparkfun.com/products/10264

Beschreibung:
 Ein einfacher Flex-Sensor 2,2 "in der Länge.Wie der Sensor gebogen wird, erhöht sich der Widerstand über den Sensor.Patentierte Technologie von Spectra Symbol - sie behaupten, diese Sensoren wurden in der ursprünglichen Nintendo Power Glove verwendet.Ich liebe den Nintendo Power Glove.
Es ist so schlecht!

Der Widerstand des flexiblen Sensors ändert sich, wenn sich die Metallpolster auf der Außenseite der Biegung befinden (Text auf der Innenseite der Biegung).
Der Steckverbinder ist 0,1 "beabstandet und Brotbrett freundlich. Datenblatt für volle Spezifikationen überprüfen.
Hinweis:
Vermeiden Sie es, diesen Sensor an der Basis zu biegen oder zu belasten. Der nutzbare Bereich des Sensors kann problemlos gebeugt werden, doch ist darauf zu achten, dass die Biegung außerhalb des nutzbaren Bereichs minimiert wird. Um optimale Ergebnisse zu erzielen, befestigen Sie den Sockel und den unteren Teil und lassen Sie den tatsächlichen Biegsensor nur biegen.


Der Flex-Sensor hat auch einen variablen Widerstand, aber der Widerstand dieses Sensors ändert sich entsprechend dem Biegen (Biegen).
Es enthält Kohlenstoff auf einem Streifen aus Kunststoff, wie ein variabler Widerstand zu handeln.

Der Flex-Sensor kann für Servomotorregelung, Intensitätsregelung oder überall dort eingesetzt werden, wo der Widerstand bei der Biegung geändert werden muss.
Hier die Schaltung mit Arduino und LED, wenn der Flex-Sensor biegt die Intensität der LED-Änderungen entsprechend.

Flex-Sensor-Arduino

Schaltplan

Flex-Sensor-Schaltung

Hier die LED mit PWM-Ausgang Pin von arduino verbunden.
Wenn der Widerstand des flexiblen Sensors den pwm-Ausgangsimpuls ändert, ändert sich daher die Intensität der LED in Bezug auf den Sensorwert.

Arduino Flex Sensor Sketch / Code:

/*www.theorycircuit.com*/
const int flexpin = 0;
                          //int led = 13;
int led = 9;

void setup() {
Serial.begin(9600);
}


void loop() {
int flexposition;                   // Input value from the analog pin.

flexposition = analogRead(flexpin); // Read the position of the flex sensor (0 to 1023):
analogWrite(led, flexposition);
Serial.print("sensor: ");
Serial.print(flexposition);

delay(20);
}

http://www.theorycircuit.com/flex-sensor-with-arduino/

48) Home > Arduino Projects > Temperatur Sensor LM35 with Arduino
LM35 Temperatur-Sensor   (pin-A0)   -  Serial

http://www.watterott.com/de/LM35CZ

Temperaturfühler LM35 TO-92  mit Arduino

Um die Temperatur zu finden, haben wir mehrere Möglichkeiten, aber die erste Wahl ist LM 35 Temperatursensor IC. Der LM35 erkennt die Temperatur zwischen -55 ° C und 150 ° C mit einer Genauigkeit von ± 5%. Es kann leicht mit Arduino-Board verbunden werden.

TemperaturSensorLM35-Arduino

Schaltplan

TemperaturSensorLM35-Schaltung

Hier haben wir die grundlegende Schnittstellenschaltung mit arduino und Skizzencode zur Anzeige des Sensorwertes im seriellen Port von arduino gegeben. In der Arduino-Platine ist der Ausgangsanschluss des LM 35 mit A0 verbunden, der ein analoger Eingangsanschluss ist. + Vcc und Gnd von der Arduino-Platine können dem Temperatursensor als Vorspannung zugeführt werden.

Arduino Temperaturfühler (LM35) Sketch / Code:

/*Source: www.theorycircuit.com*/
int val;
int tempPin = 1;
void setup() {

Serial.begin(9600);
}
void loop() {
val = analogRead(tempPin);

float mv = ( val/1024.0)*5000;
float cel = mv/10;
float farh = (cel*9)/5 + 32;
Serial.print("TEMPRATURE = ");
Serial.print(cel);
Serial.print("*C");
Serial.println();
delay(1000);
/* uncomment this to get temperature in farenhite
Serial.print("TEMPRATURE = ");
Serial.print(farh);
Serial.print("*F");
Serial.println();
*/
}

http://playground.arduino.cc/Main/LM35HigherResolution

http://www.theorycircuit.com/temperatur-sensor-lm35-with-arduino/




Sketch:

int LM35 = A0;
float SensorValue = 0;
float temperatur = 0;
float temp[5];

void setup() {
Serial.begin(9600);
}

void loop() {
SensorValue = analogRead(LM35);
temp[1] = (5.0 * analogRead(LM35) * 100.0) / 1024;
delay(1000); // 1 Sekunde Pause zwischen den Messungen machen
temp[2] = (5.0 * analogRead(LM35) * 100.0) / 1024;
delay(1000);
temp[3] = (5.0 * analogRead(LM35) * 100.0) / 1024;
delay(1000);
temp[4] = (5.0 * analogRead(LM35) * 100.0) / 1024;
delay(1000);
temp[5] = (5.0 * analogRead(LM35) * 100.0) / 1024;

temperatur = (temp[1] + temp[2] + temp[3] + temp[4] + temp[5])/5; //Mittelwert aus 5 Messungen bilden
//Serial.print(SensorValue, DEC);
//Serial.print(“ –> „);
Serial.print(temperatur, 1); //Ausgabe der Temperatur mit einer Nachkommastelle
Serial.println(„Grad Celsius“);
}

Ausblick

Software aufhübschen
Genauigkeit erhöhen -> http://www.arduino.cc/playground/Main/LM35HigherResolution

Links

Sehr ausführlicher und hilfreicher Artikel: Noch ein LM35 Temperatursensor an nem Arduino
http://www.mats-vanselow.de/arduinotemperatur
http://learn.adafruit.com/tmp36-temperature-sensor (englisch)

49) Home > Arduino Projects > Interface ultrasonic sensor (HC-SR 04) with arduino
HC-SR04 US-Sensor   (pin-8 Trig   pin-9 Echo)   -  LED oder Buzzer (pin-13)  -  Serial

Schnittstelle Ultraschallsensor (HC-SR 04) mit Arduino



Schaltplan

Arduino Ultraschall

Schaltplan

HC-SR04

Diese Schaltung kann für Sicherheitsalarm, unsichtbarem Zaun mit Warnung oder Abstandsmaß (Cm) usw. verwendet werden ...
Das Sensormodul HC-SR04 arbeitet nach dem Prinzip der Ultraschallwellenübertragung und Ultraschallwellenreflexion (Echo).
Die Zeitdifferenz zwischen Senderwelle und Echowelle wird berechnet, um den Abstand zwischen Sensormodul und Objekten zu finden.

Arduino-Code / Sketch

/*
HC-SR04 Ping distance sensor
VCC to arduino 5v GND to arduino GND
Echo to Arduino pin 9 Trig to Arduino pin 8
Buzzer +ve to Arduino pin 13 and GND to GND
Original code sourced from theorycircuit.com
Some code and wiring inspired by arduino.cc
*/

#define trigPin 8
#define echoPin 9
#define Buzzer 13


void setup() {
Serial.begin (9600);
pinMode(trigPin, OUTPUT);
pinMode(echoPin, INPUT);
pinMode(Buzzer, OUTPUT);

}


void loop() {
digitalWrite(trigPin, LOW);
delayMicroseconds(2);
digitalWrite(trigPin, HIGH);
delayMicroseconds(10);
digitalWrite(trigPin, LOW);

duration = pulseIn(echoPin, HIGH);
distance = (duration/2) / 29.1;

if (distance < 30)
{
digitalWrite(Buzzer,HIGH); //less than 30cm then buzzer will produce beep sound

}
else {
digitalWrite(Buzzer,LOW);
}

if (distance >= 200 || distance <= 0)
{
Serial.println("Out of range");
}
else {
Serial.print(distance);
Serial.println(" cm");
}
delay(500);
}

DIN A4 ausdrucken
*********************************************************
Impressum: Fritz Prenninger, Haidestr. 11A, A-4600 Wels, Ober-Österreich, mailto:[email protected]
ENDE