Analoge-Signale‎ > ‎

Messgeräte Ansteuerung


http://sites.prenninger.com/arduino-uno-r3/analoge-signale/messgeraete-ansteuerung

http://www.linksammlung.info/

http://www.schaltungen.at/

                                                                                          Wels, am 2017-02-08

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

DIN A3 oder DIN A4 quer ausdrucken
*******************************************************************************I**
DIN A4  ausdrucken   (Heftrand 15mm / 5mm)     siehe     http://sites.prenninger.com/drucker/sites-prenninger
********************************************************I*
015_b_PrennIng-a_arduino.uno.r3-analoge.signale-messgeraete.ansteuerung (xx Seiten)_1a.pdf




ARDUINO VoltAmmeter

Arduino Wattmeter – Voltage, Current and Power Measurement


#include <LiquidCrystal.h>
int Read_Voltage = A1;
int Read_Current = A0;
const int rs = 2, en = 4, d4 = 9, d5 = 10, d6 = 11, d7 = 12;
LiquidCrystal lcd(rs, en, d4, d5, d6, d7);
float Voltage = 0.0;
float Current = 0.0;
float Power = 0.0;



void setup()
{
lcd.begin(16, 2);
Serial.begin(9600);
lcd.print(" Arduino ");
lcd.setCursor(0, 1);
lcd.print(" Wattmeter ");
delay(2000);
lcd.clear();
}


void loop()
{
Voltage = analogRead(Read_Voltage);
Current = analogRead(Read_Current);
Voltage = Voltage * (5.0/1023.0) * 6.46;
Current = Current * (5.0/1023.0) * 0.239;
Serial.println(Voltage);
Serial.println(Current);
Power = Voltage * Current;
Serial.println(Power);
lcd.setCursor(0, 0);
lcd.print("V="); lcd.print(Voltage);
lcd.print(" ");
lcd.print("I=");lcd.print(Current);
lcd.setCursor(0, 1);
lcd.print("P="); lcd.print(Power);
delay(1000);
}




https://www.electronicshub.org/arduino-wattmeter/




********************************************************I*
Akku-Kapazität Tester mit ARDUINO UNO R3

Arduino-Lithium Akku Tester | Arduino ProjektHier zeige ich euch wie ihr mit einfachen mitteln einen Kapazitäts tester Bauen könnt. Programmcode :
https://goo.gl/iq8kwi
https://www.youtube.com/watch?v=CWqKYLCRn2E


EB#5 Arduino Batterie Kapazitäts-Tester - Operationsverstärker Design
Ich stelle ein Messgerät zur Überprüfung der Kapazität von handelsüblichen AA Batterien, vorzugsweise Alkaline, vor.
Die Batterien werden dabei mit einem konstannten Strom bis zu einer definierten Schlussspannung entladen.
https://www.youtube.com/watch?v=Gl1ISn4Dsfc
https://www.google.at/imgres?



Akku Kapazitätsmessung mit Arduino
https://www.komputer.de/wordpress/archives/358


Akkutester im Eigenbau mit Arduino

Um meine Akkus zu testen habe ich angefangen, einen Tester zu bauen.
Mittelfristig soll es automatisch zwischen NiMH, LiFe, LiPo, LiIon unterscheiden und eine grafische anzeige haben.
https://www.rc-modellbau-schiffe.de/wbb2/index.php?thread/40637-akkutester-im-eigenbau-mit-arduino/


Akku-Kapazität Tester (Arduino)
Dies ist mein erster Versuch am Arduino und es ist meine Engineering-Design-Projekt ist. Das ist ziemlich einfach zu machen.
Zunächst einmal müssen Sie wissen, wie Sie analoge und digitale Wert auf Arduino messen.
https://www.clickoslo.com/akku-kapazitat-tester-arduino.html


Arduino wahre Kapazität Batterietester (Li-Ionen/NiMH/NiCD/Pb)
Es wird feststellen, ob es durch den Spannungsbereich NiMH/NiCD oder Li-Ion ist.
Und starten Sie dann die Entladezyklus.
http://www.genstr.com/arduino-wahre-kapazitat-batterietester-li-ionen-nimh-nicd-pb_7.html


DIY Arduino Battery Capacity Tester - V1.0
https://www.instructables.com/DIY-Arduino-Battery-Capacity-Tester-V10-/




Akkutester für NiMH Modellbauakkus
Akkutester für NiMH-Akkus mit 4, 5 und 6 Zellen
https://www.arduinoforum.de/arduino-Thread-Akkutester-f%C3%BCr-NiMH-Modellbauakkus


Batteriemessung mit Arduino
https://garage-lab.de/allgemein/batteriemessung-mit-arduino/



Arduino Energiezähler Für Solaranlage
https://www.instructables.com/Arduino-Energiez%C3%A4hler-F%C3%BCr-Solaranlage/


ARDUINO ENERGY METER
https://www.clickoslo.com/arduino-energy-meter.html


Arduino basiertes Batterie Analysegerät – „ABA“
https://1dev.de/arduino-basiertes-batterie-analysegeraet/64/


DIY Arduino Battery Capacity Tester - V2.0
https://www.instructables.com/DIY-Arduino-Battery-Capacity-Tester-V20/


Akku Kapazitätsmessung mit Arduino

Nachdem wir hier im Haus mal wieder eine Batterie und Akkusammlung veranstaltet haben.
Aus allen Batteriebetriebenen Geräten, Spielzeugen etc. wurden alle Akkus und Batterien zusammengetragen.
https://www.komputer.de/wordpress/archives/358


Akku-Kapazität-Tester (3 / 9 schritt)
http://www.genstr.com/akku-kapazitat-tester_4.html


Arduino wahre Kapazität Batterietester (Li-Ionen/NiMH/NiCD/Pb) (6 / 11 schritt)
http://www.genstr.com/arduino-wahre-kapazitat-batterietester-li-ionen-nimh-nicd-pb_7.html


Simple Arduino Battery Capacity Tester
https://create.arduino.cc/projecthub/sim-flynn-13/simple-arduino-battery-capacity-tester-3e35e5


Akku-Kapazität-Tester (4 / 9 schritt)

Schritt 4: Vollständige Schaltpläne
http://www.genstr.com/akku-kapazitat-tester_5.html






********************************************************I*
               Internet-Luftqualitätsmesser

Abbildung 4-8
Die Schaltung für ein vernetztes Messgerät.
Der Ethernet-Controller im Schaltplan ist auf dem Shield oder dem Arduino Ethernet-Modul.



In diesem Projekt wirst du eine Internet-Messstation für Luftqualität bauen.
Du brauchst ein analoges Einbau-Messgerät, so wie in einem Tachometer oder einer Hi-Fi-Aussteuerungsanzeige.
Ich habe meins vom Flohmarkt, aber du könntest auch in einem Elektronik- oder Gebrauchtwarenladen Glück haben.
Das in der Einkaufsliste empfohlene Teil ist nicht so schön wie meins, aber es reicht als Platzhalter, bis du eins findest, das dir gefällt.


Abbildung 4-8 zeigt, wie es funktioniert:
Der Mikrocontroller baut über den Ethernet-Shield eine Verbindung zu einem PHP-Skript auf.
Das PHP-Skript verbindet sich mit einer anderen Webseite, liest eine Zahl von dieser Seite und schickt die Zahl zurück an den Mikrocontroller.
Der Mikrocontroller nimmt diese Zahl und stellt daraufhin die Anzeige des Messgeräts ein.
Die eingesetzte Website ist AIRNow, www.airnow.gov, die Seite der US-Umweltschutzbehörde, die über die Luftqualität informiert.
Dort wird stündlich neu die Luftgüte in vielen US-Städten nach Postleitzahl (ZIP code) angegeben.
Am Ende des Projekts hast du ein Messgerät zu Hause oder im Büro, das dir die momentane Luftqualität in deiner Stadt angibt (sofern du in den USA wohnst).

MATERIALIEN
1x  Arduino Ethernet oder
1x Arduino Ethernet-Shield und ein Arduino-Mikrocontroller
1x Ethernet-Verbindung zum Internet
1x Steckbrett (BreadBoard)
1x Analog-Voltmeter
4x LEDs
4x 220R Widerstände

Ansteuerung des Messgeräts mit dem Mikrocontroller
Zuerst musst du mit dem Mikrocontroller eine veränderbare Spannung erzeugen, um das Messgerät zu steuern.
Mikrocontroller können keine Analogspannungen ausgeben, aber sie können eine Reihe von sehr schnellen Ein-/Aus-Impulsen erzeugen, die gefiltert werden können, um eine Durchschnittsspannung zu ergeben.
Je höher das Verhältnis von Signal und Pause in jedem Impuls ist, desto höher ist die Durchschnittsspannung.
Diese Technik nennt man Pulsbreitenmodulation, englisch pulse-width modulation (PWM).
Damit ein PWM-Signal als Analogspannung wirkt, muss die Schaltung, die die Impulse erhält, viel langsamer reagieren als die Taktrate der Impulse.
Wenn du
z.B. eine LED mit PWM ansteuerst, sieht es so aus, als ob sie gedimmt wäre, weil dein Auge den Wechsel zwischen Ein-und Ausschalten nicht erkennen kann, wenn er schneller als etwa 30-mal pro Sekunde erfolgt.
Analoge Voltmeter reagieren sehr langsam auf Spannunsänderungen, also lassen sie sich sehr gut mit PWM ansteuern.
Indem du den positiven Anschluss des Messgeräts an eineh Ausgangs-pin des Mikrocontrollers und den negativen Anschluss an Masse anschließt und den Ausgangspin per PWM  steuerst, kannst du einfach die Position der Nadel einstellen.


Abbildung 4-9 zeigt den gesamten Schaltplan für das Projekt.


Das Programm  testet, ob du das Voltmeter steuern kannst.
Du wirst den Bereich von pwmValue in Abhängigkeit von der Empfindlichkeit des Anzeige einstellen müssen.
Die Voltmeter, die ich beim Entwurf dieses Projekts benutzt habe, hatten unterschiedliche Anzeigebereiche.
Das Voltmeter aus der Einkaufsliste reagiert auf einen Bereich von 0 bis 5 Volt, das obige Programm bewegt den Zeiger also über die gesamte Skala.

Das antike Messgerät reagiert dagegen nur von 0 bis 3 Volt, daher war es nötig, den Bereich von pwmValue auf 0 bis 165 zu begrenzen.
Bei einem Wert von 165 erreichte der Zeiger das Maximum. Notier dir den Minimal- und Maximalwert deines Voltmeters.
Du brauchst sie später, um die Luftgütemessung auf die Skala abzugleichen.



/*
Voltmeter-Tester
Steuert ein Voltmeter über analogWrite()
Kontext: Arduino
*/

const int meterPin = 9;

int pwmValue = 0;        // der Wert für das Voltmeter
void setup()
{
Serial.begin(9600);
}


void loop()
{
                         // beweg das Voltmeter vom niedrigsten zum höchsten Wert
for (pwmValue = 0; pwmValue < 255; pwmValue ++)
{
analogWrite(meterPin, pwmValue);

Serial.println(pwmValue);
delay(10);

}
delay(1000);
                             // Nullstellung und Pause
analogWrite(meterPin, 0);
delay(1000);

}

Quelle:
O'REILLY - Making Things Talk  Seite 127




*********************************************************
                      7.8    Testprojekt: Chamäleonkuppel
Das letzte Projekt in diesem Kapitel ist eine Kuppel, die ihre Farbe an die Oberfläche anpasst, auf der sie liegt.
Dazu verwenden wir den Farbsensor und geben die gemessene Farbe mit einer RGB-LED wieder.
Wenn Sie die Elektronik in ein ansprechendes Gehäuse verpacken, wirkt das Gerät sehr eindrucksvoll.

Chamäleonkuppel leuctet in verschiedenen Farben

7.8.1    Lernziele
Im Projekt »Chamäleonkuppel« lernen Sie Folgendes:
 - Ein Gerät bauen, das seine Farbe wie ein Chamäleon an die Umgebunganpasst
 - Beliebige Farben mit einer RGB-LED anzeigen
 - Weißes Rauschen durch gleitende Mittelwerte herausfiltern
 - Eingangswerte mithilfe einer Übergangsfunktion Ausgabewerten zuordnen

7.8.2 RGB-LEDs
Eine RGB-LED (siehe Abb. 7-23) sieht zwar aus wie eine einzelne LED, vereint unter der Haube aber drei LEDs.
Durch die Mischung von Rot, Grün und Blau kann sie jede beliebige Farbe anzeigen.
Das menschliche Auge verfügt nur über Rezeptoren für die drei Grundfarben Rot, Grün und Blau.
Aus diesem Grund werden diese Farben auch bei Fernsehern und anderen Anzeigegeräten benutzt.
Eine Besonderheit (oder ein Fehler) des menschlichen Auges besteht darin, dass es Kombinationen von Frequenzen als eine andere Frequenz wahrnimmt.
Das bedeutet, dass Sie rotes und grünes Licht mischen können, um gelbes Licht zu erzeugen.


Eine RGB-LED verfügt normalerweise über vier Anschlüsse, nämlich einen für jede Grundfarbe (Rot, Grün, Blau) und einen gemeinsamen Kontakt.

Anders als Sie vielleicht erwarten, ist der gemeinsame Kontakt bei vielen RGB-LEDs positiv, also eine sogenannte gemeinsame Anode.
Daher müssen Sie einen Farbanschluss (Rot, Grün, Blau) auf LOW setzen (0 V oder Masse), damit die entsprechende Farbe erscheint.

LEDs mit gemeinsamer Kathode

Bei einer RGB-LED mit gemeinsamer Kathode (negativer gemeinsamer Kontakt) müssen Sie sowohl die Schaltung als auch den Code ändern.
Bei der Schaltung müssen Sie den gemeinsamen Kontakt mit Masse verbinden statt mit +5,0 V.
Im Code müssen Sie auf die Umkehrung der Farbintensität (255-Farbe) in analogWrite( ) verzichten.
Beispielsweise muss es statt analogWrite (redPin, 255-red) dann analogWrite(redPin, red) heißen.


Woran können Sie erkennen, welcher Anschluss zu welcher Farbe gehört und welcher die gemeinsame Anode darstellt?

Die Kontakte einer RGB-LED identifizieren
Die Identität der Anschlüsse können Sie durch Probieren ermitteln.
   Schalten Sie den Arduino ein, indem Sie ihn über USB mit einer Stromquelle verbinden.
Da Sie nur den +5-V- und den Masseanschluss (GND) verwenden, spielt es keine Rolle, welcher Code auf dem Arduino ausgeführt wird.

Wir verwenden hier eine 5,0V LED.
Wenn Sie nur LEDs für geringere Spannungen haben, können Sie für den Farbtest den +3,3V Anschluss verwenden und bei der eigentlichen Schaltung einen Widerstand einbauen.


Schließen Sie am Arduino ein rotes Kabel an +5,0V und ein schwarzes Kabel an Masse an.

Verbinden Sie die beiden Kabel mit zwei beliebigen benachbarten Anschlüssen der RGB-LED.
Probieren Sie nacheinander alle Paare von benachbarten Kontakten aus, bis die LED leuchtet.
Probieren Sie dann einige andere Kombinationen von Kontakten aus, bis Sie es schaffen, das rote, das grüne und das blaue Element der RGB-LED getrennt voneinander zum Leuchten zu bringen.
Dazu muss ein Kontakt ständig mit dem roten +5,0V-Kabel verbunden sein (die gemeinsame Anode), während Sie die anderen drei nacheinander an das schwarze Massekabel anschließen.
Sollten Sie feststellen, dass der Anschluss für die gemeinsame Anode länger ist als die anderen, können Sie diese Tatsache nutzen, um sie später einfacher wiederzufinden.
Anderenfalls markieren Sie den Anschluss der gemeinsamen Anode mit einem Stück Klebeband oder beschriften ihn
(z. B. mit A für Anode, + für positiv oder was immer für Sie die beste Gedächtnisstütze ist).

Falls Sie einen Kontakt immer mit dem schwarzen GND-Kabel verbinden und die anderen nacheinander an das rote +5-V-Kabel anschließen müssen, haben Sie es mit einer LED mit gemeinsamer Kathode zu tun.
Lesen Sie in diesem Fall den Kasten »LEDs mit gemeinsamer Kathode« weiter vorn.

Kennzeichnen Sie die restlichen Anschlüsse mit Bezeichnungen für die zugehörige Farbe (R, G oder B).

7.8.3    Code und Schaltung für RGB-LEDs am Arduino




Abb. 7-24    Anschluss der RGB-LED an den Arduino


// hellorgb.ino - Mischt Farben mit der RGB-LED
// (c) BotBook.com - Karvinen, Karvinen, Valtokari

const int redPin=11;    // 1
  Wie viele andere RGB-LEDs ....
const int greenPin=10;
const int bluePin=9;

void setup()
{
pinMode(redPin, OUTPUT);
pinMode(greenPin, OUTPUT);
pinMode(bluePin, OUTPUT);

}void loop()
{
setColor(255, 0, 0);   // 2
  Um die RGB-LED aufleuchten ....
delay(1000);

setColor(255, 255, 255);
delay(1000);

}

void setColor(int red, int green, int blue)
{
analogWrite(redPin, 255-red);    // 3
  Da der Pin auf LOW gesetzt ...
analogWrite(greenPin, 255-green);
analogWrite(bluePin, 255-blue);

}



Listing 7-10 hellorgb.ino
// 1   Wie viele andere RGB-LEDs hat auch die hier verwendete einen gemeinsamen positiven Anschluss.
Das bedeutet, dass die Datenpins auf LOW oder 0 V gesetzt werden müssen, um die zugehörige Einzel-LED zum Leuchten zu bringen.

// 2    Um die RGB-LED aufleuchten zu lassen, rufen Sie setCol or () mit der gewünschten Farbe auf.
Die Parameter sind die R-, G- und B-Anteile, die jeweils einen Wert von 0 (kein Anteil) bis 255 (Maximum) aufweisen können.

// 3    Da der Pin auf LOW gesetzt werden muss, um die zugehörige Farbe aufleuchten zu lassen, müssen wir hier umgekehrt vorgehen, als man normalerweise denken würde.
Wenn beispielsweise redPi n den Wert HIGH hat (255), dann ist die rote LED ausgeschaltet.
Ist der Pin dagegen LOW (0), dann leuchtet die rote LED mit maximaler Helligkeit.




7.8.4    Gleitender Mittelwert

Mit einem sanften Farbübergang wirkt die Chamäleonkuppel viel besser, als wenn sie willkürlich von einer Farbe zur anderen wechseln würde.
Dies ist jedoch eine der Gefahren bei der Arbeit mit Sensoren:
Es kann vorkommen, dass ein Sensor die Farbe Rot einen Augenblick lang für Grün hält.
Rauschen ist bei jeder Messung ein Problem, und Sensoren bilden dabei keine Ausnahme.
Stellen Sie sich vor, Sie messen die Höhe eines kleinen Baumes.
Um Fehler möglichst auszuschließen, führen Sie mehrere Messungen durch.
Dabei erhalten Sie folgende Werte:
102 cm, 100 cm, 180 cm, 103 cm, 105 cm
Wahrscheinlich werden Sie die 180 cm sofort als Schreibfehler verwerfen.
Zum Glück kann ein Computer das auch.
Die Vorgehensweise, die einem dafür als Erstes einfällt, besteht darin, die Werte in einem Array zu speichern und dann bei jedem Durchlauf den Durchschnittswert der Elemente in dem Array zu berechnen.
Das würde zwar funktionieren, doch würde das sehr viel Code für eine so einfache Aufgabe erfordern:
Sie bräuchten ein Array, einen Zeiger, einen Durchschnitt und einige Berechnungen bei jedem Durchlauf.
Hier kommen uns gleitende Mittelwerte zu Hilfe!
Sie können den Durchschnitt des aktuellen und des vorherigen Werts berechnen, um eine gewisse Glättung zu erreichen.
Um dabei mehr Datenpunkte betrachten zu können, ohne auf eine Tabelle zurückgreifen zu müssen, können Sie einen gewichteten gleitenden Mittelwert verwenden.
Dabei könnten Sie ein Gewicht von 70 % auf den neuen Eingang legen, sodass 30 % auf die älteren Werte entfallen.

input = 0.7*input + 0.3*old
old = input


Da der alte Wert (old) aus den älteren Datenpunkten hervorgeht, brauchen Sie kein Array.




7.8.5    Beliebige Farben mit RGB-LEDs erzeugen    PWM
Um eine ganze Palette von Farben zu erzeugen, müssen Sie Rot, Grün und Blau in verschiedenen Anteilen mischen.
Wenn Sie alle drei Einzel-LEDs auf volle Helligkeit setzen, ergibt sich fast weißes Licht.
Setzen Sie alle auf minimale Helligkeit, bleibt es dunkel.
Eine LED kann nicht richtig gedimmt werden. Wenn Sie die Spannung senken, nimmt die Helligkeit zwar ab, aber irgendwann ist der Punkt erreicht, an dem die LED einfach ausgeht (und zwar deutlich bevor 0 V erreicht sind).
Um dieses Problem zu umgehen, setzt der Arduino eine Pulsbreitenmodulation (PBM = PWM in englisch) ein.
Damit es so aussieht, als würde eine LED mit 10% Helligkeit leuchten, wird die PBM mit einem Tastverhältnis von 10% durchgeführt.
Das heißt, dass der Arduino die LED 10% der Zeit eingeschaltet lässt und 90% der Zeit ausgeschaltet.
Da die LED dabei aber sehr schnell ein- und ausgeschaltet wird (jeder Zyklus dauert nur 2 Millisekunden oder 2000 Mikrosekunden), ist kein Flackern zu erkennen.
Bei einem Tastverhältnis von 10% schaltet der Arduino die LED für 200 Mikrosekunden ein und lässt sie dann 1800 Mikrosekunden lang ausgeschaltet, woraufhin der Zyklus erneut beginnt.
Um diese Einzelheiten müssen Sie sich im Code jedoch nicht kümmern.
Sie tun einfach so, als würden Sie für die verschiedenen Helligkeitsstufen einfach einen entsprechenden Wert für die Spannung (zwischen 0 und 255) anlegen.
Da der gemeinsame Kontakt HIGH ist und die einzelnen LEDs jeweils am hellsten leuchten, wenn der zugehörige Anschluss auf LOW gesetzt wird, erhalten Sie beispielsweise ein strahlendes Rot mit

analogWrite (redPin , 0)


Für alle Helligkeiten zwischen Minimum und Maximum ziehen wir den Wert für die jeweilige Farbe von 255 ab:

analogWrite(redPin, 255-r)

Um ein Gefühl für die Grundfarben zu bekommen, schauen Sie sich Tabelle 7-1 an.
Tab. 7-1    Pinwerte für Farben bei einer RGB-LED

Damit können Sie alle Regenbogenfarben erzeugen. Experimentieren Sie einfach mit der Mischung von Rot, Grün und Blau!


7.8.6 Eingänge in Ausgänge umwandeln

Wenn Eingang und Ausgang unterschiedliche Arten von Werten annehmen, muss der Code eine Konvertierung zwischen diesen Werten vornehmen.
Im einfachsten Fall ist der Ausgang einfach das Produkt aus dem Eingang und einer Zahl.
Die Konvertierung besteht also aus einer Multiplikation.
Beispielsweise hat die Arduino-Funktion analogRead( ) einen Wertebereich von 0 bis 1023, anallogWrite( ) dagegen einen Definitionsbereich von 0 bis 255.
Um zwischen diesen Bereichen umzurechnen, müssen Sie zunächst ermitteln, welchen prozentualen Anteil p des maximalen Eingangswerts der gegebene Eingangswert in darstellt:

p = in/1023

Der entsprechende Ausgangswert beträgt dann p % des maximalen Ausgangswerts:
out = p*255

Die Arduino-Bibliothek bietet sogar eine Hilfsfunktion für diese Berechnung:
out = map(in, 0, 1023, 0, 255)



Tabelle 7-2 zeigt einige Beispiele für solche linearen Konvertierungen.
Tab. 7-2    Lineare Zuordnung vom Eingang zum Ausgang mit map( )

Manche Ausgänge können allerdings nicht gut mit linear ansteigenden Eingängen umgehen.
In solchen Fällen müssen Sie eine Übergangsfunktion anwenden.
Die RGB-LED in diesem Projekt ist ein gutes Beispiel für einen solchen Ausgang.
Die Farbmischung der RGB-LED findet meistens im Bereich niedriger Werte statt.
Nahe der Obergrenze der Ausgangswerte erscheint das Licht weiß, und die einzelnen Farben lassen sich kaum unterscheiden.
Eine Übergangsfunktion ordnet die Eingänge den Ausgängen auf nicht lineare Weise zu.
Für eine RGB-LED eignet sich dafür eine Exponentialfunktion.
Anderenfalls würden die meisten Werte nur helles, weißes Licht statt Mischfarben wie Orange oder Violett hervorrufen.
Als Erstes müssen Sie den Eingang als Prozentwert ausdrücken:

p = in/1023

Berechnen Sie daraus nun einen nicht linearen Ausgang.
Der untere und der obere Grenzwert, 0 und 255, bilden immer noch die Grenzen für den Bereich der möglichen Werte.
Für die Chamäleonkuppel verwenden wir eine Exponentialfunktion als Übergangsfunktion:

out = 255 * p hoch 4

Da der Prozentwert p maximal 1,0 (100 %) beträgt, bleibt die Potenz p hoch 4 stets zwischen 0,0 (0 %) und 1,0 (100 %).
Der Verlauf der Exponentialfunktion hat die klassische »Hockeyschläger-Form«.


Beispielwerte sehen Sie in Tabelle 7-3.
Tab. 7-3    Exponentialfunktion als Übergangsfunktion


Übergangsfunktionen werden auch bei Animationen verwendet.
Wenn sich Objekte bewegen und dann anhalten, wird die Geschwindigkeit anhand einer solchen Funktion erhöht und verringert.


7.8.7 Code für eine Kombination aus RGB-LED und Farbsensor
usw.


Quelle:
O'REILLY - Making Things Talk  Seite 197



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





 
Comments