theoryCIRCUIT‎ > ‎

ARDUNO sketche

http://sites.prenninger.com/arduino-uno-r3/theorycircuit/arduno-sketche

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)
***************************************************************

                                           Verzeichnis
                          http://sites.prenninger.com/arduino-uno-r3/theorycircuit






01) Home > Arduino Projects > Arduino Flame Sensor Interface
KY-026 Flame sensor module (pin-A0 oder pin-2) - Piezo-Buzzer (pin-13)
Bauen Sie einen Brandmelder oder Brandmelder mit Flammenfühler und Arduino-Platine auf, erkennt der Sensor grundsätzlich die Infrarot-Lichtwellenlänge zwischen 760 nm und 1100 nm (Nanometer), die von der Feuerflamme abgegeben wird.
Die meisten der Flamme Sensoren kam mit YG1006 Sensor, der eine hohe Geschwindigkeit und hochempfindliche NPN-Silizium-Fototransistor ist.

Es ist mit schwarzem Epoxidharz bedeckt, da der Sensor empfindlich gegenüber Infrarotstrahlung ist.

Mit diesem Konzept-Projekt können Sie verstehen, wie zu überwachen und Alarm über Feuer Flamme, ist es am besten geeignet für Brandbekämpfung Roboter, Feueralarm etc ..,


Flammenfühler-Modul


Smart Electronics 4pin Flame Sensor Fire Detection Module Ignition Source Detects Infrared Receiver For Arduino Diy LM393
Arduino KY-026 Flame sensor module
Meeeno Einstellbare Version Flammwächter Brick für Arduino

- Flame sensor
- Farbe blau
- Material: Leiterplatte
- Verwendung des Komparators LM393 DIL-8
- Arbeitsspannung: 3,3..12V
- Ausgabeformat: 0 und 1 Digit
- Erfassungsbereich: 760nm .. 1100nm
- Erfassungswinkel: Ungefähr 60 Grad, besonders empfindlich auf das Flammenspektrum
- Einstellbare Empfindlichkeit (Potentiometer-Einstellung)
- Der Komparatorausgang, das Signal ist sauber, große fahrende Fähigkeit, mehr als 15mA
- Mit festem Schraubenloch für einfache Montage
- Kann im ARDUINO DIY Projekt verwendet werden
- Der Flammenfühler ist empfindlich auf Flamme und reagiert auf normales Licht, wird in der Regel bei Flammenwarnungen usw. verwendet.
- Der Sensor und die Flamme sollten einen gewissen Abstand beibehalten, um hohe Temperaturen zu vermeiden
- Abmessungen: 48x14x7 mm)

http://www.fut-electronics.com/wp-content/plugins/fe_downloads/Uploads/Flame-sensor-arduino.pdf

http://henrysbench.capnfatz.com/henrys-bench/arduino-sensors-and-input/logo-sensor-1-3-flame-detector-arduino-user-manual-and-tutorial/


LM393 pin-3 mit A0 verbunden
Schaltung Flame sensor module

Komparatorverstärker für Ausgangsantrieb wählen und hier zwei mögliche Ausgänge als A0 und D0 vornehmen
D0 - Geben Sie Null-Ausgang für nichts erkannt und One für eine + Ve-Erkennung.
A0 - Werte im Bereich der Flammenwahrscheinlichkeit / Größe / Distanz angeben und an den PWM-Eingang des Mikrocontrollers angeschlossen werden.



D0  Digital (pin-2) Output



/* Source: www.theorycircuit.com*/

int Buzzer = 13; // Use buzzer for alert 
int FlamePin = 2;  // This is for input pin-2
int Flame = HIGH;  // HIGH when FLAME Exposed

void setup() {
  pinMode(Buzzer, OUTPUT);
  pinMode(FlamePin, INPUT);
  Serial.begin(9600);
  
}

void loop() {
  Flame = digitalRead(FlamePin);
  if (Flame== HIGH)
  {
    Serial.println("HIGH FLAME");
    digitalWrite(Buzzer, HIGH);
  }
  else
  {
    Serial.println("No flame");
    digitalWrite(Buzzer, LOW);
  }
}





A0  Analog (pin-A0) Output





/* Source: www.theorycircuit.com */

const int analogPin = A0;    // Flame Sensor (pin-A0) to Arduino analog input pin A0
const int BuzzerPin = 13;       // Buzzer output pin
const int threshold = 400;   // Flame level threshold (You can vary the value depends on your need)

void setup() {
  
  pinMode(BuzzerPin, OUTPUT);
  // initialize serial communications:
  Serial.begin(9600);
}

void loop() {
  // read the value of the Flame Sensor:
  int analogValue = analogRead(analogPin);
   Serial.println(analogValue); //serial print the FLAME sensor value
  
  if (analogValue > threshold) {
    digitalWrite(BuzzerPin, HIGH);
    Serial.print("High FLAME");
  } 
  else if (analogValue = threshold){
    Serial.print("Low FLAME");
    digitalWrite(BuzzerPin, HIGH);
    delay(400);
    digitalWrite(BuzzerPin, LOW);
  }
  else {
    digitalWrite(BuzzerPin, LOW);
    Serial.print("No flame");
  }

  delay(1);       
}


http://www.theorycircuit.com/arduino-flame-sensor-interface/





02) Home > Arduino Projects > Fingerprint sensor-scanner with Arduino
R305 Optical Fingerprint Sensor-Scanner (pin-0 Rx   pin-1 Tx) - Piezo-Buzzer (pin-13)
Der Fingerabdruck ist einer der sichersten Weg zu erkennen und zu identifizieren, die autorisierte Person, Wir wissen, dass Fingerabdruck einzigartig ist sogar identische Zwillinge nicht identische Fingerabdrücke haben.
Mit dieser können wir ziemlich sicher über die Sicherheitsbedürfnisse.

Um Fingerabdruck-Überprüfung in Mikrocontroller-Projekte können wir dies alles in einem optischen Fingerabdruck-Sensor-Scanner (R305) hinzuzufügen, macht es Fingerabdruck-Erkennung und Überprüfung sehr einfach.


Mit diesem Sensor können wir Biometrische Authentifizierungs- und Zutrittskontroll-basierte elektronische Projekte einfach erstellen.

Open the code directly by the path in Arduino IDE: File > Example > Adafruit_Fingerprint > enroll

https://github.com/adafruit/Adafruit-Fingerprint-Sensor-Library

Verbinden Sie die Drähte gemäß dem Anschlussdiagramm.

Holen Sie sich die Fingerabdruck-Bibliothek hier und legen Sie es in Arduino ide Bibliothek Abschnitt.

Öffnen Sie den Code direkt über den Pfad in Arduino IDE: Datei -> Beispiel -> Adafruit_Fingerabdruck → registrieren
Code für die Anmeldung mit Arduino

Nach dem Hochladen dieses Codes auf das Arduino-Board öffnen Sie den seriellen Monitor, es wird Sie bitten, die ID einzugeben, um sich anzumelden.
Verwenden Sie das Kontrollkästchen oben, um eine Zahl einzugeben, und klicken Sie auf Senden.
Wagenrücklauf mit 9600 Baudrate wählen.
Nach dem Platzieren des Fingers das 2- bis 3-fache des in der spezifischen ID gespeicherten seriellen Monitors.

Code zum Zusammenpassen mit Arduino

Öffnen Sie den Code direkt über den Pfad in Arduino IDE: Datei -> Beispiel -> Adafruit_Fingerprint → Fingerabdruck


#include <Adafruit_Fingerprint.h>
#include <SoftwareSerial.h>

int getFingerprintIDez();

// pin #2 is IN from sensor (GREEN wire)
// pin #3 is OUT from arduino  (WHITE wire)
SoftwareSerial mySerial(2, 3);


Adafruit_Fingerprint finger = Adafruit_Fingerprint(&mySerial);

void setup()  
{
  Serial.begin(9600);
  Serial.println("fingertest");

  // set the data rate for the sensor serial port
  finger.begin(57600);
  
  if (finger.verifyPassword()) {
    Serial.println("Found fingerprint sensor!");
  } else {
    Serial.println("Did not find fingerprint sensor :(");
    while (1);
  }
  Serial.println("Waiting for valid finger...");
}

void loop()                     // run over and over again
{
  getFingerprintIDez();
  delay(50);            //don't ned to run this at full speed.
}

uint8_t getFingerprintID() {
  uint8_t p = finger.getImage();
  switch (p) {
    case FINGERPRINT_OK:
      Serial.println("Image taken");
      break;
    case FINGERPRINT_NOFINGER:
      Serial.println("No finger detected");
      return p;
    case FINGERPRINT_PACKETRECIEVEERR:
      Serial.println("Communication error");
      return p;
    case FINGERPRINT_IMAGEFAIL:
      Serial.println("Imaging error");
      return p;
    default:
      Serial.println("Unknown error");
      return p;
  }

  // OK success!

  p = finger.image2Tz();
  switch (p) {
    case FINGERPRINT_OK:
      Serial.println("Image converted");
      break;
    case FINGERPRINT_IMAGEMESS:
      Serial.println("Image too messy");
      return p;
    case FINGERPRINT_PACKETRECIEVEERR:
      Serial.println("Communication error");
      return p;
    case FINGERPRINT_FEATUREFAIL:
      Serial.println("Could not find fingerprint features");
      return p;
    case FINGERPRINT_INVALIDIMAGE:
      Serial.println("Could not find fingerprint features");
      return p;
    default:
      Serial.println("Unknown error");
      return p;
  }
  
  // OK converted!
  p = finger.fingerFastSearch();
  if (p == FINGERPRINT_OK) {
    Serial.println("Found a print match!");
  } else if (p == FINGERPRINT_PACKETRECIEVEERR) {
    Serial.println("Communication error");
    return p;
  } else if (p == FINGERPRINT_NOTFOUND) {
    Serial.println("Did not find a match");
    return p;
  } else {
    Serial.println("Unknown error");
    return p;
  }   
  
  // found a match!
  Serial.print("Found ID #"); Serial.print(finger.fingerID); 
  Serial.print(" with confidence of "); Serial.println(finger.confidence); 
}

// returns -1 if failed, otherwise returns ID #
int getFingerprintIDez() {
  uint8_t p = finger.getImage();
  if (p != FINGERPRINT_OK)  return -1;

  p = finger.image2Tz();
  if (p != FINGERPRINT_OK)  return -1;

  p = finger.fingerFastSearch();
  if (p != FINGERPRINT_OK)  return -1;
  
  // found a match!
  Serial.print("Found ID #"); Serial.print(finger.fingerID); 
  Serial.print(" with confidence of "); Serial.println(finger.confidence);
  return finger.fingerID; 
}


http://www.theorycircuit.com/fingerprint-sensor-scanner-arduino/





03) Home > Arduino Projects > Soil Moisture Sensor and Arduino
SEN-13322 Soil Moisture Sensor (pin-A0) - Transistor (pin-10) - Serial

Wollen Sie wissen und Daten protokollieren die Feuchtigkeit des Bodens, hier ist der Sensor, dies zu tun, hat der Feuchtigkeitssensor zwei große exponierte Pads Funktion als Sonden für den Sensor und zusammen als ein variabler Widerstand. Setzen Sie den Sensor in den Boden, wo Sie den Feuchtigkeitsgrad zu messen, abhängig von der Wasser-Präsenz in den Boden die Sensor-Leitfähigkeit zwischen den Pads variieren wird, dass mehr Wasser mehr Leitfähigkeit.

So reagieren die Sensor-Pads als Hohe Beständigkeit für trockenen Boden und niedrige Beständigkeit für nassen Boden, so dass wir das Signal hängt von der Bodenfeuchte.
Sensorausbruch.


                                                                          Sensor Breakout SparkFun SEN-13322  https://www.sparkfun.com/products/13322


Die Sensorpads erhalten Korrosion, wenn der Strom kontinuierlich durch den Sensor geleitet wird. Hier ist der Code zum Lesen zu bestimmten Zeit für die Datenerfassung zu nehmen.
Davor machen Sie die gegebene Schaltung zwischen Arduino-Board und Bodenfeuchte-Sensor.
Hier wirkt der T1 = SL100 = BC238 npn  - Transistor als Schalter zur Steuerung der Sensorversorgung.

Wenn der pin-10 von Arduino hoch geht, wird der Sensor mit Strom versorgt, wenn der pin-10 den Sensor abschaltet, der vom Netz getrennt ist.






Sketch:
int sensorPin = 0;    // select the input pin for the Soil moisture sensor
int sensorValue = 0;  // variable to store the value coming from the sensor
 
int sensorVCC = 10;    // Transistor Ansteuerung
 
void setup() {
  // declare the ledPin as an OUTPUT:
   Serial.begin(9600);  
   pinMode(sensorVCC, OUTPUT); 
   digitalWrite(sensorVCC, LOW);
}
 
void loop() {
  // power the sensor
  digitalWrite(sensorVCC, HIGH);
  delay(100); //make sure the sensor is powered
  // read the value from the sensor:
  sensorValue = analogRead(sensorPin); 
  //stop power 
  digitalWrite(sensorVCC, LOW);  
  //wait
  delay(60*1000);//delay time change according to your need          
  Serial.print("sensor = " );                       
  Serial.println(sensorValue);                   
}


Value Range:

0 ~ 300    : Dry Soil
300 ~ 700 : Humid Soil
700 ~ 950 : in Water.

http://www.theorycircuit.com/soil-moisture-sensor-arduino/




04) Home > Arduino Projects > Arduino Gesture Sensor APDS 9960

APDS9960 Soil Moisture Sensor (pin-A4 (SDA) pin-A5 (SCL) pin-2 (INT)  - Serial

Gesten- und Umgebungslichtsensor APDS-9960 von Avago Technologies hilft uns, ein einfaches und robustes Gesture Control-Projekt zu realisieren.
Der Sensor nutzt vier Richtungs-Fotodioden, um reflektiertes IR-Licht zu erfassen, um physische Bewegungsinformationen in eine digitale Information umzuwandeln (einfach Gesteninformation).
Die Architektur der Gesten-Engine bietet eine automatische Aktivierung (basierend auf Proximity-Motorenergebnissen), Umgebungslicht-Subtraktion, Übersprechstornierung,
Dual 8bit Datenkonverter, Energiesparinterkonvertierungsverzögerung, 32-Dataset-FIFO und Interrupt-gesteuertes I2C
Bus-Kommunikation.
Die Gesten-Engine bietet eine breite Palette von mobilen Geräte gesturing Anforderungen einfache UP-DOWN-RIGHT-LEFT Gesten oder komplexere Gesten können genau erfasst werden.

Leistungsaufnahme und Rauschen werden durch einstellbares IR-LED-Timing minimiert.
(Kredit von Avago Technologies).

Anwendungshinweis
Mit diesem APDS 9960 Sensor können wir Interaktion mit Arduino, Microcontroller, Computer, Roboter usw .. mit einfachen Gesten Schwung Ihrer Hand.






ARDUINO Sketch:
#include <Wire.h>
#include <SparkFun_APDS9960.h>

// Pins
#define APDS9960_INT    2 // Needs to be an interrupt pin

// Constants

// Global Variables
SparkFun_APDS9960 apds = SparkFun_APDS9960();
int isr_flag = 0;

void setup() {

  // Initialize Serial port
  Serial.begin(9600);
  Serial.println();
  Serial.println(F("--------------------------------"));
  Serial.println(F("SparkFun APDS-9960 - GestureTest"));
  Serial.println(F("--------------------------------"));

  // Initialize interrupt service routine
  attachInterrupt(0, interruptRoutine, FALLING);

  // Initialize APDS-9960 (configure I2C and initial values)
  if ( apds.init() ) {
    Serial.println(F("APDS-9960 initialization complete"));
  } else {
    Serial.println(F("Something went wrong during APDS-9960 init!"));
  }

  // Start running the APDS-9960 gesture sensor engine
  if ( apds.enableGestureSensor(true) ) {
    Serial.println(F("Gesture sensor is now running"));
  } else {
    Serial.println(F("Something went wrong during gesture sensor init!"));
  }
}

void loop() {
  if( isr_flag == 1 ) {
    detachInterrupt(0);
    handleGesture();
    isr_flag = 0;
    attachInterrupt(0, interruptRoutine, FALLING);
  }
}

void interruptRoutine() {
  isr_flag = 1;
}

void handleGesture() {
    if ( apds.isGestureAvailable() ) {
    switch ( apds.readGesture() ) {
      case DIR_UP:
        Serial.println("UP");
        break;
      case DIR_DOWN:
        Serial.println("DOWN");
        break;
      case DIR_LEFT:
        Serial.println("LEFT");
        break;
      case DIR_RIGHT:
        Serial.println("RIGHT");
        break;
      case DIR_NEAR:
        Serial.println("NEAR");
        break;
      case DIR_FAR:
        Serial.println("FAR");
        break;
      default:
        Serial.println("NONE");
    }
  }
}
http://www.theorycircuit.com/arduino-gesture-sensor-apds-9960/




05) Home > Arduino Projects > Arduino Rain sensor sketch
YL-83 Rain Sensor Module (pin-A0) - Piezo-Buzzer (pin-10) - Serial

FC-37 Rain Sensor Module
Der Regensensor verwendet FR-04 qualitativ hochwertige doppelseitige Materialien für breiteste Sensing, verwendet es LM393 Niederspannungs-Komparator mit Ausgangsleistung über 15mA.
Die Betriebsspannung dieses Moduls variiert zwischen 3,3 Volt und 5 Volt, am besten 5 V von den Arduino Power Pins.


Rain Sensor Module Sensitivity Weather Module Yl-83 for (for Arduino) Interface

Regentropfen Erkennung Sensor Modul für Arduino
rain sensor module FR-04
http://henrysbench.capnfatz.com/henrys-bench/arduino-sensors-and-input/arduino-rain-sensor-module-guide-and-tutorial/
https://randomnerdtutorials.com/guide-for-rain-sensor-fc-37-or-yl-83-with-arduino/

https://www.openhacks.com/uploadsproductos/rain_sensor_module.pdf


Dieses Projekt erklärt, wie man Regensensor mit arduino verbindet.

Es ist sehr einfaches Projekt wie das analoge Analogsignal vom Sensor nur ein Code wie "analogRead".

Aber die Anwendungen dieses Projekts haben weitreichende Möglichkeiten.

Die in verschiedenen Größen und Kategorien erhältlichen Regensensoren sind abhängig vom Sensorbereich und Komparatormodul.
So viele Online-Verkäufer verkaufen es mit vernünftigen Kosten, nur google es als Regen-Sensor werden Sie am besten erhalten.

Der Regensensor verwendet FR-04 qualitativ hochwertige doppelseitige Materialien für breiteste Sensing, verwendet es LM393 Niederspannungs-Komparator mit Ausgangsleistung über 15mA.
Die Betriebsspannung dieses Moduls variiert zwischen 3,3 Volt und 5 Volt, am besten 5 V von den Arduino Power Pins.


Rain Water Detection Sensor Module Weather Arduino

Arduino Code for Rain Sensor:
/*Arduino Rain Sensor sketch*/

int rainsense= 0; // analog sensor input pin 0
int buzzerout= 10; // digital output pin 10 - buzzer output
int countval= 0; // counter value starting from 0 and goes up by 1 every second
 
void setup(){
   Serial.begin(9600);
   pinMode(buzzerout, OUTPUT);
   pinMode(rainsense, INPUT);
}
void loop(){
   int rainSenseReading = analogRead(rainsense);
   Serial.println(rainSenseReading); // serial monitoring message 
   delay(250);// rain sensing value from 0 to 1023.
   // from heavy rain - no rain.
   if (countval >= 35){ 
      Serial.print("Heavy rain");
      digitalWrite(buzzerout, HIGH);  //raise an alert after x time
   }
   //raining for long duration rise buzzer sound
   // there is no rain then reset the counter value
   if (rainSenseReading <350){ 
      countval++; // increment count value
   }
   else if (rainSenseReading >350) { // if not raining
      digitalWrite(buzzerout, LOW); // turn off buzzer 
      countval = 0; // reset count to 0
   }
   delay(1000);
}
http://www.theorycircuit.com/arduino-rain-sensor-sketch/





06) Home > Arduino Projects > Barometric Pressure Sensor Arduino Tutorial
BMP180 BARO (pin-A4 DA  pin-A5 CL)  -  Serial

Barometrischer Druck, mit anderen Worten Atmospherischer Druck ist die Kraft, die durch die Atmosphäre an einem bestimmten Punkt ausgeübt wird (das Internet sagte). Es ist auch bekannt als das Gewicht der Luft. Dieser Artikel gibt grundlegende Idee über barometrische Drucksensor und Arduino-Interfacing-Technik.

Was ist ein barometrischer Drucksensor?

Ein Luftdruckwandler, der den Luftdruck in bezug auf die Höhe über dem Meeresspiegel von hpa umwandelt [Barometrischer Druck].

Hier nutzten wir den Drucksensor BMP180 von BOSCH. Es ist ein SMD-Gerät, so dass besser Break-Board haben.
BMP180-Digitaler Drucksensor

Der BMP180 ist der kompatible Nachfolger des BMP085, einer neuen Generation von hochpräzisen digitalen Drucksensoren und basiert auf der Piezo-Resistive-Technologie für hohe Genauigkeit.

Eigenschaften von BMP180

    
Druckbereich: 300 ... 1100hPa (+ 9000m ... -500m bezogen auf Meeresspiegel)
    
Versorgungsspannung: 1.8 ... 3.6V (VDD)
    
Paket: LGA Paket mit Metalldeckel
    
Niedrige Energie: 5μA bei 1 Probe / sec. Im Standardmodus
    
Geringes Rauschen: 0,06 hPa (0,5 m) im Ultra-Low-Power-Modus - 0,02 hPa (0,17 m) erweiterte Auflösung
    
Temperaturmessung inbegriffen
    
I²C-Schnittstelle

BMP 180 Breakout board

SparkFun Barometric Pressure Sensor Breakout - BMP180 SEN-11824  https://www.sparkfun.com/products/11824



Der Sensor BMP 180 verfügt über vier wichtige interne Peripheriegeräte wie Sensorelement, ADC (Analog-Digital-Wandler), Steuergerät und EEPROM. Das Sensorelement gibt dem ADC transduziertes & abgetastetes Signal, dann wandelt ADC das Signal in digitale Daten um, die Steuereinheit kommuniziert mit externen Peripheriegeräten über eine serielle I2C-Schnittstelle. Der Sensor BMP180 verfügt über einen eigenen E²PROM mit 176 Bit, der zur Kompensation von Offset-, Temperaturabhängigkeit und anderen Parametern des Sensors dient.


Das Arduino Druckwandler-Breakout-Board von Sparkfun.

Die kleine und kompakte Breakout-Board kommt mit einfach zu Plugin-Terminals wie +, -, CL und DA. Können wir diese Sensorplatine ohne Vorschaltung direkt mit Arduino verbinden.



Der IO in der Sensorplatine repräsentiert die I / O-Spannung und wir können die Verbindung unterbrechen, wenn Sie nicht an einen Mikrocomputer oder Mikrocontroller mit niedrigerer Spannung angeschlossen sind. Verbinden Sie das '+' - Terminal mit dem 3,3-V-Pin des Arduino. (Anmerkung: Nicht an + 5V anschließen oder der Sensor wird beschädigt!). Verbinden Sie '-' mit dem Masseanschluss (GND) der Arduino-Platine. Dann verbinden Sie die seriellen I²C-Pins DA (SDA) und CL (SCL) mit den entsprechenden Pins Ihres Entwicklungsboards. In unserem Fall verwenden wir Arduino uno so 'CL' zu A5 und 'DA' zu A4. Durch das Anschließen von Zigbee oder Wireless Transceiver können wir barometrischen Drucksender und Empfänger



Barometric pressure sensor Arduino code:

/* Code from sparkfun's Library Example*/
#include <SFE_BMP180.h>
#include <Wire.h>

SFE_BMP180 pressure;

#define ALTITUDE 1655.0 // Altitude of SparkFun's HQ in Boulder, CO. in meters

void setup()
{
  Serial.begin(9600);
  Serial.println("REBOOT");

  // Initialize the sensor (it is important to get calibration values stored on the device).

  if (pressure.begin())
    Serial.println("BMP180 init success");
  else
  {
    // Oops, something went wrong, this is usually a connection problem,
    // see the comments at the top of this sketch for the proper connections.

    Serial.println("BMP180 init fail\n\n");
    while(1); // Pause forever.
  }
}

void loop()
{
  char status;
  double T,P,p0,a;

  // Loop here getting pressure readings every 10 seconds.

  // If you want sea-level-compensated pressure, as used in weather reports,
  // you will need to know the altitude at which your measurements are taken.
  // We're using a constant called ALTITUDE in this sketch:
  
  Serial.println();
  Serial.print("provided altitude: ");
  Serial.print(ALTITUDE,0);
  Serial.print(" meters, ");
  Serial.print(ALTITUDE*3.28084,0);
  Serial.println(" feet");
  
  // If you want to measure altitude, and not pressure, you will instead need
  // to provide a known baseline pressure. This is shown at the end of the sketch.

  // You must first get a temperature measurement to perform a pressure reading.
  
  // Start a temperature measurement:
  // If request is successful, the number of ms to wait is returned.
  // If request is unsuccessful, 0 is returned.

  status = pressure.startTemperature();
  if (status != 0)
  {
    // Wait for the measurement to complete:
    delay(status);

    // Retrieve the completed temperature measurement:
    // Note that the measurement is stored in the variable T.
    // Function returns 1 if successful, 0 if failure.

    status = pressure.getTemperature(T);
    if (status != 0)
    {
      // Print out the measurement:
      Serial.print("temperature: ");
      Serial.print(T,2);
      Serial.print(" deg C, ");
      Serial.print((9.0/5.0)*T+32.0,2);
      Serial.println(" deg F");
      
      // Start a pressure measurement:
      // The parameter is the oversampling setting, from 0 to 3 (highest res, longest wait).
      // If request is successful, the number of ms to wait is returned.
      // If request is unsuccessful, 0 is returned.

      status = pressure.startPressure(3);
      if (status != 0)
      {
        // Wait for the measurement to complete:
        delay(status);

        // Retrieve the completed pressure measurement:
        // Note that the measurement is stored in the variable P.
        // Note also that the function requires the previous temperature measurement (T).
        // (If temperature is stable, you can do one temperature measurement for a number of pressure measurements.)
        // Function returns 1 if successful, 0 if failure.

        status = pressure.getPressure(P,T);
        if (status != 0)
        {
          // Print out the measurement:
          Serial.print("absolute pressure: ");
          Serial.print(P,2);
          Serial.print(" mb, ");
          Serial.print(P*0.0295333727,2);
          Serial.println(" inHg");

          // The pressure sensor returns abolute pressure, which varies with altitude.
          // To remove the effects of altitude, use the sealevel function and your current altitude.
          // This number is commonly used in weather reports.
          // Parameters: P = absolute pressure in mb, ALTITUDE = current altitude in m.
          // Result: p0 = sea-level compensated pressure in mb

          p0 = pressure.sealevel(P,ALTITUDE); // we're at 1655 meters (Boulder, CO)
          Serial.print("relative (sea-level) pressure: ");
          Serial.print(p0,2);
          Serial.print(" mb, ");
          Serial.print(p0*0.0295333727,2);
          Serial.println(" inHg");

          // On the other hand, if you want to determine your altitude from the pressure reading,
          // use the altitude function along with a baseline pressure (sea-level or other).
          // Parameters: P = absolute pressure in mb, p0 = baseline pressure in mb.
          // Result: a = altitude in m.

          a = pressure.altitude(P,p0);
          Serial.print("computed altitude: ");
          Serial.print(a,0);
          Serial.print(" meters, ");
          Serial.print(a*3.28084,0);
          Serial.println(" feet");
        }
        else Serial.println("error retrieving pressure measurement\n");
      }
      else Serial.println("error starting pressure measurement\n");
    }
    else Serial.println("error retrieving temperature measurement\n");
  }
  else Serial.println("error starting temperature measurement\n");

  delay(5000);  // Pause for 5 seconds.
}

http://www.theorycircuit.com/barometric-pressure-sensor-arduino-tutorial/




07) Home > Arduino Projects > Pulse Sensor with Arduino
APDS-9008  Puls Sensor   (pin-A0) - LED (pin-13) - LED (pin-5) - Serial
Herzfrequenzdaten können in vielen elektronischen Design- und Mikrocontroller-Projekten verwendet werden. Aber die Herzfrequenz Daten ist schwer zu lesen, aber die Pulse Sensor Amped helfen uns, Herzfrequenz zu lesen. Der Pulse Sensor Amped ist ein Plug-and-Play-Herzfrequenzsensor für Arduino. Es kann von Studenten, Künstlern, Athleten, Entscheidungsträgern und Spielern und mobilen Entwicklern verwendet werden, die Live-Herzfrequenz-Daten in ihre Projekte integrieren möchten.Es vereinigt im Wesentlichen einen einfachen optischen Herzfrequenzsensor mit Verstärkung und Rauschunterdrückung Schaltung, die es schnell macht Und einfach, zuverlässige Impulsablesungen zu erhalten.



Hier spielt der APDS-9008 Miniatur-Licht-Lichtsensor von Avago eine wichtige Rolle, und er ist dafür verantwortlich, die Konzentration des Lichts wieder über Fingerspitze oder Ohrläppchen nachzuweisen.
D1 LED gibt Lichtquelle für diesen Betrieb.

Signal vom Umgebungslichtsensor verstärkt durch OP Amp und das Signal ist bereit, durch den Mikrocontroller zu lesen.




Pulse Sensor Arduino Code:

/*>> Pulse Sensor Amped 1.2 
<<This code is for Pulse Sensor Amped by Joel Murphy and Yury Gitman www.pulsesensor.com    
Check here for detailed code walkthrough:
http://pulsesensor.myshopify.com/pages/pulse-sensor-amped-arduino-v1dot1
Code Version 1.2 by Joel Murphy & Yury Gitman  Spring 2013
This update fixes the firstBeat and secondBeat flag usage so that realistic BPM is reported.*/


//  VARIABLES
int pulsePin = 0;                 // Pulse Sensor purple wire connected to analog pin 0
int blinkPin = 13;                // pin to blink led at each beat
int fadePin = 5;                  // pin to do fancy classy fading blink at each beat
int fadeRate = 0;                 // used to fade LED on with PWM on fadePin


// these variables are volatile because they are used during the interrupt service routine!
volatile int BPM;                   // used to hold the pulse rate
volatile int Signal;                // holds the incoming raw data
volatile int IBI = 600;             // holds the time between beats, must be seeded! 
volatile boolean Pulse = false;     // true when pulse wave is high, false when it's low
volatile boolean QS = false;        // becomes true when Arduoino finds a beat.


void setup(){
  pinMode(blinkPin,OUTPUT);         // pin that will blink to your heartbeat!
  pinMode(fadePin,OUTPUT);          // pin that will fade to your heartbeat!
  Serial.begin(115200);             // we agree to talk fast!
  interruptSetup();                 // sets up to read Pulse Sensor signal every 2mS 
   // UN-COMMENT THE NEXT LINE IF YOU ARE POWERING The Pulse Sensor AT LOW VOLTAGE, 
   // AND APPLY THAT VOLTAGE TO THE A-REF PIN
   //analogReference(EXTERNAL);   
}



void loop(){
  sendDataToProcessing('S', Signal);     // send Processing the raw Pulse Sensor data
  if (QS == true){                       // Quantified Self flag is true when arduino finds a heartbeat
        fadeRate = 255;                  // Set 'fadeRate' Variable to 255 to fade LED with pulse
        sendDataToProcessing('B',BPM);   // send heart rate with a 'B' prefix
        sendDataToProcessing('Q',IBI);   // send time between beats with a 'Q' prefix
        QS = false;                      // reset the Quantified Self flag for next time    
     }
  
  ledFadeToBeat();
  
  delay(20);                             //  take a break
}


void ledFadeToBeat(){
    fadeRate -= 15;                         //  set LED fade value
    fadeRate = constrain(fadeRate,0,255);   //  keep LED fade value from going into negative numbers!
    analogWrite(fadePin,fadeRate);          //  fade LED
  }


void sendDataToProcessing(char symbol, int data ){
    Serial.print(symbol);                // symbol prefix tells Processing what type of data is coming
    Serial.println(data);                // the data to send culminating in a carriage return
  }

http://www.theorycircuit.com/pulse-sensor-arduino/



Fitness-Tracker
PPG-Sensoren senden grünes, rotes oder infrarotes Licht aus, das Haut, Gewebe und Blutgefäße durchstrahlt und auf den Detektor reflektiert wird.
Da Blut Licht absorbiert, lässt sich aus dem Detektorsignal die Herzfrequenz ableiten.


Pulsfrequenzmessung  optische Herzfrequenzmessung
Handgelenk grüne LEDs 530nm
Am Finger rote LEDs 660nm oder Infrarot mit 940nm

OSRAM Opto Semiconductors  SFH2201
Für präzise Puls-SPO2 Messungen am Handgelenk  OSRAM SFH7070  SFH7072  (grüne LEDs). Der Sensor lässt sich ohne weitere Abdeckung vom Anwender ditekt auf der Haut tragen.


Heart Rate Monitor Sensor for Arduino

https://www.dfrobot.com/product-1540.html

Heart Rate Sensor SKU: SEN0203

https://www.dfrobot.com/wiki/index.php/Heart_Rate_Sensor_SKU:_SEN0203

https://forum.arduino.cc/index.php?topic=530628.0



Gravity: Analog Heart Rate Monitor Sensor (ECG = EKG) for Arduino

EINFÜHRUNG
Der DFRobot Herzfrequenzsensor wird zur Messung der elektrischen Aktivität des Herzens verwendet.
Diese elektrische Aktivität kann als EKG aufgezeichnet und als analoger Messwert ausgegeben werden.
Ein EKG-Signal kann extrem laut sein, deshalb haben wir einen AD8232-Chip eingebaut, der ein klares Signal aus den PR- und QT-Intervallen erzeugt.
Mit der Arduino IDE "Serial Plotter" -Funktion können Sie auch die EKG-Ausgabe am PC grafisch darstellen!



Arduino Herzfrequenzsensor (EKG) -DFRobot

Um den Einsatz dieses Sensors zu erleichtern, wurde ein Gravity Interface entwickelt, um Plug & Play zu ermöglichen.
Der IO-Erweiterungsschild ist die beste Anpassung für diesen Soundsensor, der mit Ihrem Arduino verbunden ist.
Da dieser Sensor mit 3.3V arbeiten kann, ist er kompatibel mit Raspberry Pi, Intel Edison, Joule und Curie.
HINWEIS:
Dieses Produkt ist KEIN medizinisches Gerät und ist nicht dazu bestimmt, als solches oder als Zubehör dazu verwendet zu werden, noch irgendwelche Bedingungen zu diagnostizieren oder zu behandeln.

https://www.dfrobot.com/product-1510.html









08a) Home > Arduino Projects > Interfacing Load Cell with Arduino using HX711
HX711 DMS-Sensor   (pin-A0 CLK   pin-A1 DAT)  -  Serial

Elektronische Wägemaschine nutzt die Kraftmessdose, um die Last oder den Druck zu messen, der durch die Last erzeugt wird, hier folgen die meisten Wägezellen dem Verfahren des Dehnungsmeßgerätes, das den Druck (Kraft) in ein elektrisches Signal umwandelt, wobei diese Wägezellen vier Dehnungsmeßstreifen haben Verbunden mit einer Wheatstone-Brücke.
Wenn wir Belastung anwenden, ändert sich der Dehnungsmeßstreifenwiderstand und folglich ändert sich die Ausgangsspannung von der Wägezelle, indem wir den Lastwert messen können.


Wheatstone-Brücke Bildung von DMS-Aufnehmer


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



DMS 350 Ohm  2mV/V
http://www.theorycircuit.com/wp-content/uploads/2016/06/hx711.pdf



Verbinden Sie einfach die Zellenzelle mit dem HX711 Modul auf Basis ihrer Farbe, verbinden Sie dann den DAT (Data) Pin mit dem Arduino Analog Pin A1 und verbinden Sie den CLK (Clock) Pin mit dem Arduin0 Analog Pin A0, Put Vcc und Gnd mit den Arduino Power Source Pins.


Vor dem Kompilieren dieses Codes setzen Sie HX711.h Library in die Arduino-IDE.  https://github.com/bogde/HX711

Arduino Code:

// Hx711.DAT - pin #A1
// Hx711.CLK - pin #A0

#include "hx711.h"

Hx711 scale(A1, A0);

void setup() {

  Serial.begin(9600);

}

void loop() {

  Serial.print(scale.getGram(), 1);
  Serial.println(" g");

  delay(200);
}
http://www.theorycircuit.com/interfacing-load-cell-arduino-using-hx711/


08b) Home > Arduino Projects > How to Connect Load Cell to Arduino?  INA125
INA125 DMS Sensor mit DMS-Verstärker-IC  (pin-A0)  -  Serial

Elektronische Wägemaschine nutzt die Kraftmessdose, um die Last oder den Druck zu messen, der durch die Last erzeugt wird, hier folgen die meisten Wägezellen dem Verfahren des Dehnungsmeßgerätes, das den Druck (Kraft) in ein elektrisches Signal umwandelt, wobei diese Wägezellen vier Dehnungsmeßstreifen haben Verbunden mit einer Wheatstone-Brücke.

Wenn wir Belastung anwenden, ändert sich der Dehnungsmeßstreifenwiderstand und folglich ändert sich die Ausgangsspannung von der Wägezelle, indem wir den Lastwert messen können.

Wheatstone-Brücke Bildung von Lastzelle




Instrumenten-Verstärker
Die Ausgangsspannung ändert sich von der Wägezelle kann zwischen Millivolt Bereich variieren, so dass wir brauchen, um die Veränderungen in der Ausgangsspannung zu vergrößern, hier verwenden wir Instrumentenverstärker INA125.

Dies ist ein Messverstärker mit niedriger Genauigkeit und Präzision.
Es bietet vollständige Brücke Anregung und Präzision differentiellen Eingangsverstärkung auf einer einzigen integrierten Schaltung.




Schematische Darstellung

DATENBLAT Instrumentation Amplifier INA125 mit Pinbelegungsplan

http://www.theorycircuit.com/wp-content/uploads/2016/06/ina125.pdf




Der INA125 ist ein 16-poliger DIP (Dual Inline Package) IC.
Es hat zwei Stufen des Verstärkers mit Referenzverstärker.



Arduino Wägezellen-Schaltpläne



Schließen Sie die Wägezellen an den Messverstärker wie im Schaltplan gezeigt an.

ROT         : Erregung +
WEISS     : Signal +
GRÜN       : Signal -
SCHWARZ: Eregung -

Der zwischen pin-8 und pin-9 geschaltete Widerstand 10Ω ist für die Verstärkung des Instrumentenverstärkers INA125 verantwortlich, der Ausgang wird aus Vo und Sense (pin-10 & pin-11) kombiniert und in den Arduino Analog pin-A0 eingespeist.
Hier die Notwendigkeit der Stromversorgung für Wägezelle und Instrumentierung Verstärker gelöst durch Arduino Power Pins.

Diese Schaltung ist für das Lesen am seriellen Terminal entworfen, wenn Sie Display-Display LCD-Schnittstelle mit Arduino hinzufügen müssen.

http://www.theorycircuit.com/drive-lcd-display-with-arduino-2/

Arduino-Code für Wägezelle:


// Load cells are linear. So once you have established two data pairs, you can interpolate the rest.

// Step 1: Upload this sketch to your arduino board

// You need two loads of well know weight. In this example A = 10 kg. B = 30 kg
// Put on load A 
// read the analog value showing (this is analogvalA)
// put on load B
// read the analog value B

// Enter you own analog values here
float loadA = 10; // kg
int analogvalA = 200; // analog reading taken with load A on the load cell

float loadB = 30; // kg 
int analogvalB = 600; // analog reading taken with load B on the load cell

// Upload the sketch again, and confirm, that the kilo-reading from the serial output now is correct, using your known loads

float analogValueAverage = 0;

// How often do we do readings?
long time = 0; // 
int timeBetweenReadings = 200; // We want a reading every 200 ms;

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

void loop() {
  int analogValue = analogRead(0);

  // running average - We smooth the readings a little bit
  analogValueAverage = 0.99*analogValueAverage + 0.01*analogValue;

  // Is it time to print? 
  if(millis() > time + timeBetweenReadings){
    float load = analogToLoad(analogValueAverage);

    Serial.print("analogValue: ");Serial.println(analogValueAverage);
    Serial.print("             load: ");Serial.println(load,5);
    time = millis();
  }
}

float analogToLoad(float analogval){

  // using a custom map-function, because the standard arduino map function only uses int
  float load = mapfloat(analogval, analogvalA, analogvalB, loadA, loadB);
  return load;
}

float mapfloat(float x, float in_min, float in_max, float out_min, float out_max)
{
  return (x - in_min) * (out_max - out_min) / (in_max - in_min) + out_min;
}
http://www.theorycircuit.com/how-to-connect-load-cell-to-arduino/





09) Home > Arduino Projects > SST Liquid Level Sensor with Arduino
SEN-13835 Liquid Level Sensor  (pin-7)  -  LED und Buzzer (pin-13)
Mit dem SST-Füllstandsensor können wir den Flüssigkeitsstand über TTL-kompatible Gegentaktausgänge ermitteln. Dieser Sensorteil ist mit robustem Material abgedeckt, ermöglicht es uns, in begrenztem Bereich der Erfassung zu installieren.

Ein optischer Flüssigkeitsstandssensor verwendet eine Infrarot-LED und einen Phototransistor, der genau an der Basis der Sensorspitze positioniert ist. Wenn die Spitze Luft ist, reflektiert Infrarotlicht innerlich um die Spitze zum Phototransistor, was eine gute optische Kopplung zwischen den beiden ergibt. Wenn die Sensorspitze in Flüssigkeit eingetaucht ist, entweicht das Infrarotlicht von der Spitze, was eine Änderung in der Lichtmenge an dem Phototransistor verursacht, die den Ausgangsänderungszustand macht. (Quelle: SST Anwendungshinweis)

SST Liquid Level Sensor SEN-13835  https://www.sparkfun.com/products/13835

Supply Voltage: +4.5 Vdc to +15.4Vdc
Output Current: 100mA
Temperature Range: -25 to +80⁰C
Polysulphone Housing Tip
M12 threaded connector (mounted from outside)







Arduino Code:

// Liquid level detection using an SST sensor
//
// When a liquid touches the tip of the sensor,
// an LED at pin 13 turns on.
// 
// Hardware:
//     Sensor    | Arduino
//  -------------|---------
//    Vs (RED)   |    5V
//   Out (GREEN) |   pin 7
//   GND (BLUE)  |    GND

// Pins
const int LIQUID_SENSOR_PIN = 7;
const int LED_PIN = 13;

void setup() { 
  pinMode(LIQUID_SENSOR_PIN, INPUT);
  pinMode(LED_PIN, OUTPUT);
  digitalWrite(LED_PIN, LOW);
}

void loop() {

  // Read sensor. If liquid touches the tip, the sensor will 
  // read 0V. Turn on LED if liquid is present.
  int isDry = digitalRead(LIQUID_SENSOR_PIN);
  if ( isDry ) {
    digitalWrite(LED_PIN, LOW);
  } else {
    digitalWrite(LED_PIN, HIGH);
  }

  delay(200);
}
https://gist.github.com/ShawnHymel/a7c6cd17f00dd10e4325f72f83842be1





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

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






Comments