http://www.linksammlung.info/

http://www.schaltungen.at/

                                                                                               Wels, am 2017-01-01

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

DIN A3 oder DIN A4 quer ausdrucken
**********************************************************************************
DIN A4  ausdrucken
*********************************************************

Untergeordnete Seiten (6):
37-in-1 Sensor

                            37-in-1 Module
a

                     7 Analog-Sensor-Module mit gleicher Platine
                       und 2-fach Komparator LM393 mit Poti 100k

 Schaltbilder und Anschlüsse der verwendeten 37-in-1 Sensoren und Aktoren.
















37-in-1 Sensor Kit elektor-Symbole TL1_1c.bbs












37-in-1 Sensor Kit elektor-Symbole TL2_1c.bbs




Wer sich die vielen Sensoren aus dem 37-in-1 Kit genau ansieht, wird schnell bemerken, daß viele die gleichen Platinen verwenden.
Das ist nicht nur kostengünstig, sondern auch sinnvoll, weil ähnliche Prinzipien zugrunde liegen.
Ein gutes Beispiel liefert die gleiche Beschaltung des NTC-Temperatursensors (Analog Temp) und des LDR-Sensors (Photoresistor).
Beides sind Sensoren, die ihren Widerstand in Abhängigkeit von den üblicherweise in einem Spannungsteiler mit einem Festwiderstand verwendet.
Der Spannungsteiler ist besonders einfach und hat trotzdem einen Genauigkeitsvorteil.
Wenn nämlich dieselbe Spannung verwendet wird, heben sich Fehler auf, die auf eine ungenaue Spannung zurückgehen.
Wenn man den 5V Anschluss des Arduino verwendet, erhält man an dieser Stelle recht genaue bei einer Versorgung über USB.
Der AD-Wandler liefert aber unabhängig von einer genauen Spannung den gleichen Wert, der sich aus dem Verhältnis der Meßspannung zur Referenz ergibt.
Damit erfasst man sozusagen direkt das Widerstandsverhältnis in der Sensorschaltung.
So wie die beiden Sensoren angeschlossen sind, erhält man bei mehr Licht und höherer Temperatur jeweils eine sinkende Spannung.

Das muss man bei der Programmierung beachten.


704_d_#14-07s32-x_160152-11 Sensoren (1) 37-in-1 - Digital 30_1a.pdf

    Elektor Extension-Shield www.elektormagazine.de/140009  Print-Layout 140009-PCB.pdf

704_d_#14-07s32-x_140009-11 Elektor Extension-Shield für Sensoren (0) 37-in-1_1a.pdf
      DE2014070321.pdf

PB8..13 = Port B (ARDUINO UNO R3 pin-8, -9, -10, 11, -12 -13)  Frei nutzbar
PB2 (pin-10) LED2 auf dem Extension-Shield  über Jumper, auch als PWM-Ausgang verwendbar
PB5 (pin-13) LEDsmd auf dem ARDUINO UNO
PD0..7 = Port D (ARDUINO pin-0, -1, -2, -3, -4, -5, -6, -7) Vollständig belegt von LCD auf Extension-Shield und UART
pin-A0 und pin-A1: Taster S1 und S2 gegen GND, aber auch als Analogeingänge nutzbar
pin-A2: Extension LED1 über Jumper, sonst frei, bevorzugter Eingang für analoge Sensoren
pin-A3: Linear-Poti 10k auf dem Extension-Shield
pin-A4 und pin-A5: normalerweise FREI, werden aber manchmal für I2C-Interface verwendet

Der Microcontroller IC ATmega328p hat alle möglichen Pinbezeichnungen ich verwende die vom ARDUINO UNO R3 Board
Analog Eingang ADC2 = AD2 = PC2 = pin-A2 (Rohwerte value 0..1023 in Spannung voltage 0 .. 5,00V).

In den Elektor Unterlagen werden Pinbezeichnungen verwendet die weder am uC noch am ARDUINO zu finden sind.

Eine von mir erstellte Tabelle damit sich auch Anfänger auskennen,
 was bei Elektor Schaltungen nicht der Fall ist ! ! !

Mein erstes Shield :-)  DE2014070321.pdf
ARDUINO UNO R3 pin        Controller-Pin    Funktionen auf dem Shield
                          uC ATmega328P       
pin-17 (SCL)              Pin28 (PC5 C5)    EEC-SCL   (I2C-BUS)
pin-16 (SDA)              Pin27 (PC4 C4)    EEC-SDA   (I2C-BUS)

pin-13 (IO13/SCK/) smdLED Pin19 (PB5 B5)    ISP-SCK
pin-12 (IO12/MISO)        Pin18 (PB4 B4)    ISP-MISO
pin-11 (IO11/PWM/MOSI)    Pin17 (PB3 B3)    ISP-MOSI
pin-10 (IO10/PWM/SS)      Pin16 (PB2 B2)    ISP-SS     LED2
pin-9  (IO9/PWM)          Pin15 (PB1 B1)    ECC-GPIOB
pin-8  (IO8)              Pin14 (PB0 B0)    ECC-GPIOA
pin-7  (IO7)              Pin13 (PD7 D7)    LCD-D7
pin-6  (IO6/PWM)          Pin12 (PD6 D6)    LCD-D6
pin-5  (IO5/PWM)          Pin11 (PD5 D5)    LCD-D5
pin-4  (IO4)              Pin06 (PD4 D4)    LCD-D4
pin-3  (IO3)              Pin05 (PD3 D3)    LCD-E
pin-2  (IO2)              Pin04 (PD2 D2)    LCD-RS
pin-1  (IO1/TxD)          Pin03 (PD1 D1)    ECC-TxD  (freihalten)
pin-0  (IO0/RxD)          Pin02 (PD0 D0)    ECC-RxD  (freihalten)

pin-A0 (AD0)              Pin23 (PC0 C0)    S1 Taster 1
pin-A1 (AD1)              Pin24 (PC1 C1)    S2 Taster 2
pin-A2 (AD2)              Pin25 (PC2 C2)                LED1
pin-A3 (AD3)              Pin26 (PC3 C3)    P1 (Potentiometer 10k)
pin-A4 (AD4)              Pin27 (PC4 C4)    EEC-SDA  (I2C-BUS)
pin-A5 (AD5)              Pin28 (PC5 C5)    EEC-SCL  (I2C-BUS)

LCD 2x8 Display mit HD44780 Controller

Bild 2. Das Extension-Shield erweitert den Arduino Uno um 3 LEDs, 2 Taster, ein 10k Poti und ein Display.



Es geht alles auch ohne elektor Extension-Shield, stecken Sie einfach einen
ATmega328P und ein LCD-Display 2x8 Zeichen  DIPS082-HNLED - HD44780  in ein BreadBoard

Spannungsmessung mit Arduino
Die C-Programmierung mit der Arduino-IDE unterscheidet sich nicht sehr von der Basic-Programmierung in Bascom.
Das universell nutzbare Programm VoltageAD2.ino (Listing 2) setzt ebenfalls die Rohwerte (value) vom AD-Wandler in die Spannung (voltage) in mV um.
Zugleich zeigt das Beispiel die Ansteuerung des LCD speziell auf dem Elektor Shield.
Die Spannung wird auf dem LCD in Volt ausgegeben.
Das Ergebnis hat ohne weitere Formatierung zwei Nachkommastellen.
Die gesendeten Messergebnisse (Spannungen in mV) kann man sich im seriellen Monitor ansehen (Bild 5).
Ab der Arduino-Software 1.6.8 gibt es zusätzlich den seriellen Plotter (Bild 6), der ebenfalls einfache Zahlenfolgen empfängt und darstellt.
Dabei entsteht ein fortlaufendes Diagramm wie auf einem Plotter mit endloser Papierrolle.
Der Messbereich passt sich laufend an die gesendeten Daten an.
Der kleinste Messbereich reicht von -10.0 bis +10.0.


Bild 6. Messwerte im seriellen Plotter.

JoyStick Modul KY-023

Analog Eingang ADC4 = AD4 = PC4 = pinA4 (Rohwerte value 0..1023 in Spannung voltage 0 .. 5,00V)
Analog Eingang ADC5 = AD5 = PC5 = pinA5 (Rohwerte value 0..1023 in Spannung voltage 0 .. 5,00V)

// JoystickRGB.ino    Joystick pin-A4 pin-A5 (pin-A1)

//                                    RGB-LED Anoden pin-9, -10, -11  Kathode pin-12

// elektor Extensions-Shield  pin-2, -3, -4, -5, -6, -7

#include <LiquidCrystal.h>
int joyX = A4;
int joyY = A5;
int red = 9;
int green = 10;
int blue = 11;
int cathode = 12;
int value;
int midX;
int midY;

LiquidCrystal lcd(2,3,4,5,6,7); 

void setup() {
  Serial.begin(9600);
  lcd.begin(16, 2);
  midX = analogRead(joyX);
  midY = analogRead(joyY); 
  pinMode(cathode, OUTPUT);
  digitalWrite(cathode, LOW);
}

void loop() {
  value = analogRead(joyX);
  value = constrain(value, 35, 980);
  lcd.setCursor(0, 0);
  lcd.print(value);
  lcd.print("     ");
  if (value >(midX+200)) {
    analogWrite(red , 0);
    analogWrite(green , 0);
    analogWrite(blue , 0);
  }
  if (value <(midX-2)) {
    analogWrite(blue, (midX - value)/2);
  }
  value = analogRead(joyY);
  value = constrain(value, 35, 980);
  lcd.setCursor(0, 1);
  lcd.print(value);
  lcd.print("     ");
  if (value > midY) {
    analogWrite(red, value -midY);
  }
  if (value > (midY+2)) {
    analogWrite(red, (value - midY)/2);
  }
  if (value < (midY-2)) {
    analogWrite(green, (midY - value )/2);
  }
  delay(500);
}



Analog temp Modul KY-013

Analog Eingang ADC2 = AD2 = PC2 = pinA2 (Rohwerte value 0..1023 in Spannung voltage 0 .. 5,00V)

// NTCtempAD2.ino        NTC10k  pin-A2

// Relais pin-10

// elektor Extensions-Shield  pin-2, -3, -4, -5, -6, -7
#include <LiquidCrystal.h>
int sensorPin = 2;
int relaisPin = 10;
int value;
float fvalue;
float resist;
float temp;
LiquidCrystal lcd(2,3,4,5,6,7); 

void setup() {
  Serial.begin(9600);
  lcd.begin(16, 2);
  pinMode(relaisPin, OUTPUT);
}

void loop() {
  value = analogRead(sensorPin);
  fvalue = value;
  resist = fvalue / (1023-fvalue);
  temp = 1/(log (resist) / 3900 + 0.0033557) - 273;
  Serial.println(temp);
  lcd.setCursor(0, 0);
  lcd.print(temp);
  lcd.print (" C   ");
  if (temp > 25 ) digitalWrite (relaisPin, HIGH);
  if (temp < 20 ) digitalWrite (relaisPin, LOW);
  delay(500);
}





Lineares analog Poti 10k

Analog Eingang ADC2 = AD2 = PC2 = pinA2 (Rohwerte value 0..1023 in Spannung voltage 0 .. 5,00V)

// VoltageAD2.ino     0 .. 5000mV   pin-A2
// elektor Extensions-Shield  pin-2, -3, -4, -5, -6, -7
#include <LiquidCrystal.h>
int sensorPin = 2;
int value = 0;
float voltage;
LiquidCrystal lcd(2,3,4,5,6,7); 

void setup() {
  Serial.begin(9600);
  lcd.begin(16, 2);
}
void loop() {
  value = analogRead(sensorPin);
  voltage = value;
  voltage = voltage * 5000 / 1023;
  value = voltage;
  Serial.println(value);
  lcd.setCursor(0, 0);
  lcd.print(voltage/1000);
  lcd.print (" V   ");
  delay(50);
}






2 *********************************************************
7 Analog (AO) / Digital (DO) Sensor-Module mit gleicher Platine (rot) und 2-fach Komparator LM393 mit 25-Gang Poti 100k
704_d_#16-12s33-x_160173-11 Sensoren (2) 37-in-1 – Analog-Digital 7_1a.pdf


Wenn man aber einmal längere Kabel mit mehr als 30 cm verwenden will, sollte man einen Bypass-Kondensator von 100 nF direkt am Sensor zwischen die Betriebsspannungsanschlüsse legen (siehe Bild).

Bild1. Elektor Analog Modul Schaltbild

Sensoren mit Dual-Komparator LM393
Wenn man die Schaltung der Platine in Bild 1 genauer betrachtet, wird die Funktion klar.
Wieder findet man den eigentlichen Sensor in einem Spannungsteiler, der aber diesmal mit einem 25-Gang-Präzisionstrimmer einstellbar ist.
Ein zweiter Spannungsteiler aus zwei Widerständen mit 100k  liefert eine Vergleichsspannung von 2,5 V für den Komparator.
Der Temperatursensor NTC47k kann nun so eingestellt werden, dass die Sensorspannung bei einer gewünschten Temperatur ebenfalls gerade bei 2,5 V liegt.
Bei steigender Temperatur am NTC-Sensor schaltet der Komparator den digitalen Ausgang DO ein, bei fallender Temperatur schaltet er ihn aus.
Der nachgeschaltete 2. Komparator steuert nur die Status-LED an.
Dank dieser LED kann man alle sieben Sensoren bereits ganz ohne Software testen.
Die Schaltungen besitzen keinen Bypass-Kondensatoren sodass kleine Änderungen oder Störimpulse auf der Versorgungsleitung das Verhalten negativ beeinflussen können.
Das hängt außerdem noch von Leitungslängen und weiteren Zufälligkeiten ab.
Tatsächlich wurde beim NTC-Temperatursensor bei steigender Temperatur ein kleiner Bereich gefunden, in dem der Ausgang schwingt, was möglicherweise auch an parasitären Kapazitäten auf der Platine liegen kann.
Wenn man sich nämlich einen kleinen Kondensator zwischen dem Eingang und dem zweiten Komparatorausgang vorstellt, sieht man einen Oszillator.
Mit einem Oszilloskop ist dies leicht zu erkennen.
Aber auch die Status-LED auf der Sensorplatine zeigt es.
Bei langsamer Erwärmung geht sie zuerst mit halber Helligkeit an (Schwingungen) und dann erst mit voller Helligkeit (stabiler Zustand).
Wenn mal in der Software seltsame Dinge passieren, sollte man an diesen Punkt denken.
Die anderen Sensoren mit dieser Beschaltung verhalten sich ganz ähnlich, wenn auch meist keine so langsamen Änderungen der Messgröße auftreten.
Am besten vergleichbar mit dem NTC ist der Fototransistor im IR Flammensensor.
Das dunkle Gehäuse lässt bevorzugt die größeren Wellenlängen hindurch, sodass Flammen erkannt werden.
Der Hall-Sensor unterscheidet sich dadurch, dass er eine Betriebsspannung an seinem dritten Pin
erwartet. Dass auch der Reed-Schalter wie ein analoger Sensor angeschlossen wird, mag überraschen.
Aber man besitzt damit immerhin zwei gegenphasige Ausgänge.
Wenn man einen Permanent-Magneten annähert, geht der eine Ausgang an, der andere aus.
Sound und Touch verhalten sich etwas anders, sie liefern normalerweise ein Rechtecksignal mit schnellen Wechseln.
Die beiden Sound-Sensoren verwenden der eine ein großes ECM und der Andere ein kleines Elektret-Mikrofon.
Bei passender Einstellung des 25-Gang Potis erscheinen Halbwellen lauter Schallsignale als Rechtecke am Ausgang.
Das muss bei der Auswertung beachtet werden.
Genauso liefert der Touch-Sensor bei Berührung meist ein 50Hz-Rechtecksignal in Europa.






Analog Module Schaltbild  der ORIGINAL Platine angepasst



Listing 2. Der ARDUINO-Komparator
// Komparator AD1.ino   pin-A2  >  pin-10   pin-13
// elektor Extensions-Shield  pin-2, -3, -4, -5, -6, -7
#include <LiquidCrystal.h>
int sensorPin = 2;             // pin-A2  Modul Analog Sensor Eingang
int value = 0;
int output1 = 10;     // pin-10  Shield LED2
int output2 = 13;     // pin-13 ARDUINO smd-LED
int output3 = 12;     // pin-12 n.c.
 
LiquidCrystal lcd(2,3,4,5,6,7); 

void setup() {
  Serial.begin(9600);
  lcd.begin(16, 2);
  pinMode(output1, OUTPUT);
  pinMode(output2, OUTPUT);
  pinMode(output3, OUTPUT);
}
 
void loop() {
  value = analogRead(sensorPin);
  if (value > 514) {
    digitalWrite (output1, 1);
    digitalWrite (output2, 0);
  }
  if (value < 510) {
    digitalWrite (output1, 0);
    digitalWrite (output2, 1);
  }
  Serial.println(value);
  lcd.setCursor(0, 0);
  lcd.print(value);
  lcd.print ("   ");
  delay(50);                          // 50ms Pause
}



Listing 4. Port Ein- und Ausgabe mit ARDUINO
// Touch1.ino   pin-A2  >  pin-10  pin-13
#include <LiquidCrystal.h>
int input = A2;               //  Modul analog Pin-AO
int output1 = 10;          // pin-10  Shield LED2
int output2 = 13;          // pin-13 ARDUINO smd-LED
int output3 = 12;          // pin-12 n.c.
void setup() {
  pinMode(output1, OUTPUT);
  pinMode(output2, OUTPUT);
  pinMode(output3, OUTPUT);
}
 
void loop() {
  digitalWrite (output1, digitalRead(input));
  digitalWrite (output2, 1-digitalRead(input));
  delay(21);
}




Listing 6. Klopfschalter mit ARDUINO
// Touch2.ino  pin-A2  >  pin-10, pin-13
#include <LiquidCrystal.h>
int input = A1;                       //  Modul digital Pin-DO
int output1 = 10;                  // pin-10  Shield LED2
int output2 = 13;                  // pin-13 ARDUINO smd-LED
int output3 = 12;                  // pin-12 n.c.
unsigned int timeout = 0;

void setup() {
  pinMode(output1, OUTPUT);
  pinMode(output2, OUTPUT);
  pinMode(output3, OUTPUT);
}

void loop() {
  if (digitalRead(input) == 1) timeout = 50000;
  //if (digitalRead(input) == 0) timeout = 50000;
  if (timeout > 0) timeout = timeout -1;
  if (timeout > 0) {  
    digitalWrite (output1 , 1);
    digitalWrite (output2 , 0);
  }
  else {
    digitalWrite (output1 , 0);
    digitalWrite (output2 , 1);
  }
  delayMicroseconds(10);
}





Listing 6. Klopfschalter mit ARDUINO  und serieller Ausgabe
// Touch3.ino   pin-A2  >  pin-10, pin-13
#include <LiquidCrystal.h>
int input = A1;                     //  Modul digital Pin-DO
int output1 = 10;                // pin-10  Shield LED2
int output2 = 13;                 // pin-13 ARDUINO smd-LED
int output3 = 12;                 // pin-12 n.c.
int sensorPin = A2;            //  Modul analog Pin-AO
unsigned int timeout = 0;

void setup() {
  Serial.begin(9600);
  pinMode(output1, OUTPUT);
  pinMode(output2, OUTPUT);
  pinMode(output3, OUTPUT);
}

void loop() {
  if (digitalRead(input) == 1) timeout = 50;
  if (timeout > 0) timeout = timeout -1;
  if (timeout > 0) {  
    digitalWrite (output1 , 1);
    digitalWrite (output2 , 0);
  }
  else {
    digitalWrite (output1 , 0);
    digitalWrite (output2 , 1);
  }
  Serial.println(analogRead(sensorPin)+100*digitalRead (output1));
  delay (20);
}






3 *********************************************************

4 Stk.  BUS-Sensor-Module mit dunkelgrauer  Platine
704_d_#17-01s74-x_160173-11 Sensoren (3) 37-in-1 - OneWire RC5-Protok._1a.pdf

OneWire-BUS

Das Eindraht-Protokoll   OneWire-BUS  1-Wire-BUS
Alles läuft beim Eindraht-Bus über die eine Leitung DQ.
Dazu kommen allerdings noch GND und VCC.
Die Datenleitung DQ wird im Ruhezustand mit einem Pullup hochgezogen.
Der Master kann nun einen Reset-Impuls senden und damit eine Kommunikation beginnen, um dann Kommandos zu senden oder Daten zu empfangen.
Beide Partner können Daten auf den Bus legen.
Ein 0-bit wird durch einen 15μs langen Low-Impuls und einen nachfolgenden, 45μs langen High-Zustand dargestellt.
Ein 1-bit wird durch einen 60μs langen Low-Impuls symbolisiert.
Zwischen den einzelnen bits gibt es einen Ruhezustand, in dem die Datenleitung vom Pullup hochgezogen wird.
Der Master (Controller) schickt jeweils einen Reset und dann ein oder mehrere Kommandos.
Ein Sensor-Chip antwortet dann mit den gewünschten Daten.
Wer sich das Datenblatt des Chips genauer ansieht, findet darin nicht nur das allgemeine BUS-Protokoll sondern auch zahlreiche Kommandos und den Aufbau der zurückgelesenen Datenstruktur.
Die Sache wird noch komplexer, weil sogar mehrere Slaves am gleichen Bus liegen können.
Man ahnt, wieviel Arbeit es sein muss, das alles selbst zu programmieren.
Aber man muss das Rad ja nicht jedesmal neu erfinden, sondern kann fast immer auf fertigen Code zurückgreifen.



IR receiver Modul KY-001

Bild 1. Anschluss des 18B20-Temperatursensors mit 1-Wire-BUS wurde von der Firma Dallas

Man findet jeweils eine Header-Datei   *.h und eine C++-Datei   *.cpp.


Für die Datenleitung wurde der pin-A2 gewählt.





Sketch 1. Temperaturmessung mit dem DS18B20.

// DS18B20LCD.ino    pin-A2
#include <OneWire.h>
#include <DallasTemperature.h>
#include <LiquidCrystal.h>
#define ONE_WIRE_BUS A2
OneWire oneWire(ONE_WIRE_BUS);
DallasTemperature sensors(&oneWire);

float temp;
int minTemp;
int maxTemp;
LiquidCrystal lcd(2,3,4,5,6,7);


void setup(void) {
   Serial.begin(9600);
   sensors.begin();
   lcd.begin(16, 2);
   minTemp = 100;
   maxTemp = -100;
   }


void loop(void) {
   sensors.requestTemperatures();
   temp = sensors.getTempCByIndex(0);
   Serial.println(temp);
   lcd.setCursor(0, 0);
   lcd.print(temp);
   lcd.print (" C ");
   if (temp < minTemp) minTemp = temp;
   if (temp > maxTemp) maxTemp = temp;
   lcd.setCursor(0, 1);
   lcd.print(minTemp);
   lcd.setCursor(5, 1);
   lcd.print(maxTemp);
   delay (500);                // Temperaturabfrage, die sich nach jeweils 500ms wiederholt
   }






Temperatur und Luftfeuchte mit dem DHT11 (DHT22) Genauigkeit + - 1°C
Bild 4. Anschluss des Feuchte-/ Temperatursensors DHT11.

Der integrierte Feuchte- und Temperatursensor DHT11 sieht auf den ersten Blick aus wie ein einfacher resistiver Feuchtesensor.
Dieser Eindruck wird noch verstärkt, wenn man sieht, dass ein analoger Pin vorgeschlagen wird (Bild 4).
Aber tatsächlich verbirgt sich hinter dem unscheinbaren blauen Gehäuse ein komplexer Sensor mit einer digitalen Schnittstelle.

Die chinesische Firma Aosong hat sich hier etwas einfallen lassen, das nur auf den ersten Blick an den Eindraht-Bus von Dallas erinnert.
Jede Messung wird durch einen mindestens 18ms langen Low-Impuls vom Master initiiert.
Danach müssen insgesamt 40bits ausgelesen werden, was der Master jedes Mal mit einem 80μs langen Low-Impuls anfordert.
Der Sensor antwortet mit High-Impulsen, wobei eine Länge von max. 28μs für eine 0 steht und eine Länge von 70μs für eine 1.
Die 40bits enthalten dann jeweils ein Higbyte und ein Lowbyte für die Feuchte und die Temperatur und ein zusätzliches Parity-Byte zur Überprüfung der korrekten Übertragung.
Beim DHT11 stehen die Lowbytes jeweils auf Null, sodass keine Nachkommastellen übertragen werden.
Es gibt aber auch noch den DHT22 mit dem gleichen Protokoll, der auch die Nachkommastellen liefert.
Deshalb können mit der gleichen Library beide Typen ausgelesen werden.



Temp and humidity Modul KY-015

Für die Datenleitung wurde der pin-A2 gewählt.

Sketch 3. Temperatur- und Luftfeuchtemessung mit dem DHT11 in Arduino-C.

// DHT11 LCD.ino           pin-A2
#include <dht.h>
#define dht_apin A2
#include <LiquidCrystal.h>
LiquidCrystal lcd(2,3,4,5,6,7);
float temperature;
float humidity;

dht DHT;

void setup() {
   Serial.begin(9600);
   delay(500);
   delay(1000);
   lcd.begin(16, 2);
}

void loop() {
   DHT.read11(dht_apin);
   humidity = DHT.humidity;
   temperature = DHT.temperature;
   Serial.print("Humidity = ");
   Serial.print(DHT.humidity);
   Serial.println(" % ");
   Serial.print("Temperature = ");
   Serial.print(temperature);
   Serial.println(" C ");
   lcd.setCursor(0, 0);
   lcd.print(temperature);
   lcd.print (" C ");
   lcd.setCursor(0, 1);
   lcd.print(humidity);
   lcd.print (" % ");
   delay(2000);
}




Bild 6a. IR-Sender.   Infrarot-Fernbedienung



Bild 6b. IR-Empfänger


Das RC5-Protokoll / Infrarot-Fernbedienung
Infrarot-Fernbedienungen für Fernsehgeräte, Videorecorder und andere Geräte der Unterhaltungselektronik arbeiten zum Teil nach dem von Philips definierten RC5-Standard.
Man verwendet dabei modulierte Lichtsignale im Bereich 30kHz .. 36kHz.. 40kHz.
Die Fernbedienung sendet einzelne Bursts aus, also Impulspakete mit Längen von 0,888ms oder 1,776ms.
Bei einer Modulationsfrequenz von 36kHz enthält ein kurzer Burst 32 Einzelimpulse, ein langer 64.
Das gesamte Datenpaket dauert etwa 25ms und wird alle 100ms wiederholt, solange eine Taste gedrückt wird.
Das Protokoll verwendet ein Bi-Phasen-Signal.
Ein bit hat eine Länge von 1,776ms.


Wenn der 36kHz Puls in der ersten Hälfte dieser Zeit liegt, bedeutet das eine logische 0, eine logische 1 wird durch einen Impuls in der zweiten Hälfte dargestellt.
Das Signal wird mit einer immer gleich bleibenden Startsequenz eingeleitet.
Dann folgen drei Datenbereiche.

1) Das Control-Bit (Ctl) wechselt bei jeder Tastenbetätigung zwischen 0 und 1.
Der Empfänger kann auf diese Weise unterscheiden, ob eine Taste einmal lange oder mehrmals kurz gedrückt wird.

2) Die Geräte-Adresse (Adr) enthält 5bits, wobei höherwertige bits zuerst übertragen werden.
Übliche Geräteadressen sind 0 für Fernsehgeräte und 5 für Videorecorder.
Auf diese Weise können mehrere Fernbedienungen im selben Raum eingesetzt werden.

3) Der Datenbereich (Dat) enthält 6bits für bis zu 64 unterschiedliche Tasten.
Die Nummerntasten 0 bis 9 erzeugen Codes von 0 bis 9.
Auch hier werden die höchstwertigen Bits zuerst gesendet.




Für die Datenleitung wurde der pin-A2 gewählt.


IR receiver Modul KY-022
Listing 6. IR-Steuerung in Arduino-C.

//  IRrxtx    pin-RxD  pin-A2  TxD   pin-3    (IR-Fernsteuerung RC5-Protokoll)
#include <IRremote.h>
int RECV_PIN = A2;            // IR receiver am Analog-Eingang pin-A2
IRrecv irrecv(RECV_PIN);
IRsend irsend;
decode_results results;
int d;
int S1 = A0;                            // Taster 1 am elektor Extension-Shield
int S2 = A1;                            // Taster 2 am elektor Extension-Shield
int LED = 13;                        // pin-13 smdLED am Print
int kathode =2;


void setup() {
   Serial.begin(9600);
   irrecv.enableIRIn();
   pinMode(S1, INPUT_PULLUP);
   pinMode(S2, INPUT_PULLUP);
   pinMode(RECV_PIN, INPUT_PULLUP);
   pinMode(LED, OUTPUT);
   pinMode(kathode, OUTPUT);
}


void loop() {
   if (irrecv.decode(&results)) {
      Serial.println(results.decode_type);
      Serial.println(results.value, HEX);
      d = results.value & 15;
      Serial.println(d);
      if (d==2) digitalWrite(LED,1);
      if (d==0) digitalWrite(LED,0);
   }
   if (digitalRead(S1) == 0) irsend.sendRC5(0x382,32);
   if (digitalRead(S2) == 0) irsend.sendRC5(0x380,32);
   irrecv.enableIRIn();
   delay(100);                       // 0,1sec. Pause
}



4 *********************************************************

4 Stk.  BUS-Sensor-Module mit dunkelgrauer  Platine
704_d_#17-03s100-x_160302-11 Sensoren (4) 37-in-1 - Schalten und Steuern mit Licht_1a.pdf

     PulsSensor KY-039 
                      GabelLichtschranke KY-010
                                                    DrehEncoder KY-040
                                                                            LinienSensor KY-032

Schalten und Steuern mit Licht, das ist eine weit verbreitete Technik mit vielen Vorteilen.
Keine mechanische Berührung, keine Abnutzung von Schaltkontakten, elektrisch isolierte Baugruppen und vieles mehr. 


GabelLichtschranke KY-010 / ReflexLichtschranke / LinienSensor KY-032 / (tracking-sensor)

IR-Fototransistor

Listing 1. Mittelwertbildung.
// Voltage AD2 0...1023 at AD2 filter
int sensorPin = 2;
int value;
int mean;

void setup() {
   Serial.begin(9600);
   lcd.begin(16, 2);
}
void loop() {
   value = analogRead(sensorPin);
   mean = mean - mean / 20;
   mean = mean + value;
   Serial.println(value);
   Serial.println(mean / 20);
   delay(19);
}



Filter2AD2.ino
FilterAD2.ino

Listing 2. Hochpassfilter.
// Filter2AD2 0...1023 at AD2 filter
int sensorPin = 2;
int value;
int mean;

void setup() {
   Serial.begin(9600);
}
void loop() {
   value = analogRead(sensorPin);
   mean = mean - mean / 20;
   mean = mean + value;
   value = value - mean / 20;
   Serial.println(value);
   delay(19);
}






***********************
Gabellichtschranke KY-040 / Pulsmesser KY-039 / Puls-Sensor / Puls-Detektor
 (light blocking heartbeat)

PulseRateAD2.ino

Listing 3. Der Arduino-Pulsmesser.

//  PulseRateAD2 0...1023 at AD2
#include <LiquidCrystal.h>
int sensorPin = 2;
int value;
int mean;
int old;
unsigned long time1;
unsigned long time2;
int pulseTime;
int n=0;
int pulseFreq;
LiquidCrystal lcd(2,3,4,5,6,7);

void setup() {
Serial.begin(9600);
lcd.begin(16, 2);
}

void loop() {
value = analogRead(sensorPin);
mean = mean - mean / 20;
mean = mean + value;
value = value - mean / 20;
if ((old < 0) & (value > 0)) {
time2 = millis();
pulseTime = time2-time1;
time1 = time2;
//Serial.println(pulseTime);
n = n + 1;
pulseFreq = 60000 / pulseTime;
if (pulseFreq > 45) {
Serial.println(pulseFreq);
lcd.setCursor(0, 0);
lcd.print(pulseTime);
lcd.print(" ms ");
lcd.setCursor(0, 1);
lcd.print(pulseFreq);
lcd.print(" /min ");
}
}
old = value;
delay(20);
}

***********************
Drehencoder KY-040  (rotary encoder)

Listing 5. Encoder-Auswertung in Arduino-C.

Encoder.ino

//Encoder A0/A1 PMW1, A4/A5 PWM2
#include <LiquidCrystal.h>
int d1;
int d2;
int old1;
int old2;
int new1;
int new2;
int clk1 = A0;
int dt1 = A1;
int clk2 = A4;
int dt2 = A5;
int pwm1 = 9;
int pwm2 = 10;
int L = 13;
LiquidCrystal lcd(2,3,4,5,6,7);

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

lcd.begin(16, 2);
pinMode(clk1, INPUT_PULLUP);
pinMode(dt1, INPUT_PULLUP);
pinMode(clk2, INPUT_PULLUP);
pinMode(dt2, INPUT_PULLUP);
pinMode(pwm1, OUTPUT);
pinMode(pwm2, OUTPUT);
pinMode(L, OUTPUT);
digitalWrite(L, 1);
}

void loop() {
new1 = digitalRead(clk1);
if((new1==0) & (old1==1)){
if (digitalRead(dt1)==0) d1++; else d1--;
Serial.println (d1);
if (d1 > 250) d1 = 250;
if (d1 < 0) d1 = 0;
analogWrite (pwm1, d1);
lcd.setCursor(0, 0);
lcd.print(d1 * 20);
lcd.print(" mV ");
}
old1=new1;

new2 = digitalRead(clk2);
if((new2==0) & (old2==1)){
if (digitalRead(dt2)==0) d2++; else d2--;
Serial.println (d2);
if (d2 > 250) d2 = 250;
if (d2 < 0) d2 = 0;
analogWrite (pwm2, d2);
lcd.setCursor(0, 1);
lcd.print(d2 * 20);
lcd.print(" mV ");
}
old2=new2;

}

PWM Brückenschaltung

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