Hallo Miteinander, ich suche noch eine bessere Möglichkeit als eine FORbefehlsschleife zum Dimmen von LED`s mit einem analogen Sensor.
MfG
Crazydiver
was ist denn dein ziel?
das der Loop durch die FOR Schleife nicht blockiert wird?
Dein Sketch in Code Tags wäre da denke ich mal Hilfreich
Gruß
Micha
Du hast einen analogen Sensor an Ax und möchtest
damit einen PWM wert ausgeben um eine LED zu dimmen?
Richtig verstanden?
Stefan
Moin Micha, ich habe folgendes vor: Bei einem LCDisplay die Hintergrundbeleuchtung dimmen und zwar über einen Licht Sensor Modul für Arduino.Die Regelung sollte bei Dunkelheit dunkler werden und bei sehr hellen Licht ist groß möglichste Helligkeit haben.Leider habe ich bisher nur ein Sketch gefunden bei dem die LED über eine for Schelfe mit delay an einem PWM Ausgang gesteuert wird.Aber ich möchte es aber über den Sensor machen.Meine bisherige Lösung war auch noch nicht richtig.
MfG
Crazydiver
#include <Wire.h> // I2C Umsetzer
#include <LiquidCrystal_I2C.h> //Display einbinden
LiquidCrystal_I2C lcd1(0x27, 16, 2); //Displays initalisieren
LiquidCrystal_I2C lcd(0x26, 20, 4);
const int LED1 = 13;
const int LED2 = A1;
const int schalterpin = 8;
const int potPin = A0;
int schalterPin = 8; // Signalpin 8 fuer Textumschaltung
int textumschalter = 0; // Signal Textumschaltung
int val;
void setup() {
val = analogRead(A0);
val = map(val,0,1023,0,1023);
digitalWrite(LED2, val);
lcd.backlight(); // beide Displaybeleuchtungen an
lcd1.backlight();
lcd.init(); // Displays loeschen
lcd1.init();
pinMode(LED1, OUTPUT);
pinMode(LED2, OUTPUT);
pinMode(schalterpin, INPUT);
}
void loop() {
lcd.init(); // Displays loeschen
lcd1.init();
textumschalter = digitalRead(schalterPin);
if (textumschalter == LOW){
digitalWrite(LED1, LOW);
lcd.setCursor(6,0);
lcd.print("Vorsicht");
lcd.setCursor(3,1);
lcd.print("Ausnahmekonvoi");
lcd.setCursor(8,2);
lcd.print("Lu`s");
lcd.setCursor(4,3);
lcd.print("Spezialtrans");
lcd1.setCursor(4,0);
lcd1.print("Vorsicht");
lcd1.setCursor(1,1);
lcd1.print("Ausnahmekonvoi");
}
// Umschaltung zum englischen Text
else if (textumschalter == HIGH) {
digitalWrite(LED1, HIGH);
lcd.setCursor(5,0);
lcd.print("Attention");
lcd.setCursor(0,1);
lcd.print("Convoi Exceptionnel");
lcd.setCursor(8,2);
lcd.print("Lu`s");
lcd.setCursor(4,3);
lcd.print("Specialtrans");
lcd1.setCursor(0,0);
lcd1.print("Attention Convoi");
lcd1.setCursor(2,1);
lcd1.print("Exceptionnel");
}
}
an welchem Pin ist dein Lichtsensormodul angeschlossen? Welche Werte liefert dein Sensor Modul bei minimaler Helligkeit und welche bei maximaler Helligkeit?
Crazydiver:
Moin Micha, ich habe folgendes vor: Bei einem LCDisplay die Hintergrundbeleuchtung dimmen und zwar über einen Licht Sensor Modul für Arduino.
Was für ein Lichtsensor-Modul?
Analoge Messung? Digitale Messung? Seriell? I2C-Bus?
Wie bekommt der Arduino von welchem Lichtsensor welche Werte?
Was ist "hell? Was dunkel?
Und das Dimmen soll die Ausgabe eines 8-Bit PWM-Werts von 0...255 per nalogWrite() Funktion sein, ja?
Hallo,
wenn ich euch meine Schwippbogen LED Regelung an den Kopf knalle, hoffe ich das ihr damit etwas anfangen könnt.
/*
Doc_Arduino - german Arduino Forum
IDE 1.6.7
Genuino Micro
LED Helligkeitssteuerung für Schwippbogen
Timer 1: 10 Bit Fast PWM, Mode 7
TOP: 1023
Pulsweite: OCR1 (<= TOP)
Schaltpin: 10 (OC1B bzw. PB6) nicht invertiert
*/
#include <avr/pgmspace.h>
const byte _LEDpin = 10; // OC1B bzw. PB6 nicht invertiert, IRFxxxx Mosfet
const byte _LDR1pin = A0; // LDR
const byte _LDR2pin = A1; // LDR
const byte _Pot1pin = A2; // Potentiometer, Minimum Helligkeit
const byte _Pot2pin = A3; // Potentiometer, Maximal Helligkeit
float _LDR_filt; // gefilteter gleitender LDR Mittelwert
int _Index_PWM_Table;
// vorberechnete PWM Pulsweiten, linearisiert Helligkeitwahrnehmung fürs menschliche Auge
const int PWM_Table[99] PROGMEM = // 10 Bit, 99 aus 128 Werten, Gammakorrektur 3,0
{0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,2,2,2,3,3,4,5,5,6,7,8,9,10,11,12,13,
15,16,18,20,21,23,25,27,30,32,34,37,40,43,46,49,52,55,59,62,66,70,
74,79,83,88,92,97,103,108,113,119,125,131,137,144,150,157,164,171,
179,186,194,202,211,219,228,237,246,256,265,275,286,296,307,318,
329,340,352,364,376,389,402,415,428,442,456,470}; // letzte Indexposition 98
void setup() {
digitalWrite(_LEDpin, LOW); // OC1B bzw. PB6 nicht invertiert
pinMode(_LEDpin, OUTPUT);
set_Timer1();
DemoFading();
}
void loop() {
_Index_PWM_Table = calculate_PWM(); // aktualisiert LDR Werte und mapt
// auf Tabellen Indexposition
refresh_LED(_Index_PWM_Table); // aktualisiert das PWM Tastverhältnis
} // loop Ende
// ****** Funktionen ******* //
int calculate_PWM ()
{
int LDR1 = analogRead(_LDR1pin); // vorderer LDR
int LDR2 = analogRead(_LDR2pin); // hinterer LDR
int minBrightness = analogRead(_Pot1pin); // minimum Index
minBrightness = map(minBrightness, 0, 1023, 12, 30); // Bereich 12 ... 30 möglich
int maxBrightness = analogRead(_Pot2pin);
maxBrightness = map(maxBrightness, 0, 1023, (minBrightness+10), 98); // muß <= höchstem PWM_Table Index bleiben
int LDR = (LDR1+LDR2)/2; // Mittelwert beider LDRs
Filtern(_LDR_filt, LDR, 500); // sanft filtern und beruhigen
int Index_PWM_Table = map(_LDR_filt, 0, 1023, minBrightness, maxBrightness);
return Index_PWM_Table;
}
void refresh_LED (int Index_PWM_Table)
{
int PWM_Wert = pgm_read_word_near(PWM_Table + Index_PWM_Table);
OCR1B = PWM_Wert;
}
void DemoFading() // einmalig beim Start
{
static unsigned long lastTime;
static unsigned int stepTime = 5;
static unsigned int Index_PWM_Table = 0;
for (int i=0; i<=98;) { // Fading IN
if (millis() - lastTime > stepTime ) { // Fading Geschwindigkeit einhalten
Index_PWM_Table = i; // PWM_Table Index Position anpassen
lastTime = millis();
i++;
}
refresh_LED(Index_PWM_Table);
_Index_PWM_Table = calculate_PWM();
}
stepTime = stepTime+5;
for (int i=98; i>=12;) { // Fading OUT
if (millis() - lastTime > stepTime ) { // Fading Geschwindigkeit einhalten
Index_PWM_Table = i; // PWM_Table Index Position anpassen
lastTime = millis();
i--;
}
refresh_LED(Index_PWM_Table);
_Index_PWM_Table = calculate_PWM();
}
stepTime = stepTime+5;
for (int i=12; i<=_Index_PWM_Table;) { // Fading IN auf Sollwert
if (millis() - lastTime > stepTime ) { // Fading Geschwindigkeit einhalten
Index_PWM_Table = i; // PWM_Table Index Position anpassen
lastTime = millis();
i++;
}
refresh_LED(Index_PWM_Table);
_Index_PWM_Table = calculate_PWM();
}
}
void set_Timer1() // 10 Bit Fast PWM - Mode 7
{
cli(); // Interrupts ausschalten
TCCR1A = 0; // Reset TCCR1A Register
TCCR1B = 0; // Reset TCCR1B Register
TIMSK1 = 0; // Reset TIMSK1 Register (disable Timer Compare Interrupts)
TCNT1 = 0; // initialize counter value to 0
TCCR1A = (1<<COM1B1) | (1<<WGM11) | (1<<WGM10); // nicht invertiert
TCCR1B = (1<<WGM12) | (1<<CS11) | (1<<CS10); // Prescaler 64 > 244,1Hz
OCR1B = 0; // Pulsweite, OCR1x <= 1023 (2^10)
sei(); // Interrupts wieder eingeschalten
} // end Funktion
/****************************************************************************************
** Funktion Filtern() by GuntherB **
*****************************************************************************************
** Bildet einen Tiefpassfilter (RC-Glied) nach. **
** FF = Filterfaktor; Tau = FF / Aufruffrequenz ** **
** Input: FiltVal der gefilterte Wert, NewVal der neue gelesene Wert; FF Filterfaktor **
** Output: FiltVal **
** genutzte Globale Variablen: _LDR_filt (call by Reference) **
*****************************************************************************************/
void Filtern(float &FiltVal, int NewVal, int FF){
FiltVal= ((FiltVal * FF) + NewVal) / (FF +1);
}
Ein sicherlich komplexeres Bsp. findet man hier, warum nicht mal wieder verwenden zum abändern.
Hier wird ohne Blockierung gedimmt. Die loop kann jederzeit auf Dinge reagieren.
http://forum.arduino.cc/index.php?topic=378551
Moin Jurs,der Sensor hat 2 Ausgänge einen analogen und einen digitalen mit Schwelleneinstellung.Davon nutze ich den analogen der an dem Anschluß A0 verbunden ist. Dieser soll dann die Hintergrundbeleuchtung von einem I2C LCDisplay dimmen.Ich hoffe folgendes trägt zur Klärung bei welcher Sensor das ist:Fotowiderstand Entdeckung Lichtempfindlich Licht Sensor Modul für Arduino .
MfG
Crazydiver
Ich habe nun deinen Sensor nicht genau angesehen, aber im Prinzip kann das so funktionieren:
const int HellMin = 200; // Lichteinfall, ab dem die minimale Display Helligkeit angesteuert wird
const int HellMax = 800; // Lichteinfall, ab dem die maximale Display-Helligkeit angesteuert wird
void loop() {
int Hell = analogread(A0); // Lichtsensor einlesen
Hell = constrain(Hell, HellMin, HellMax); // die Werte begrenzen auf die Schwellwerte
byte PWM_Wert = map(Hell, HellMin, HellMax, 0, 255); // helligkeit in Licht-PWM umrechnen.
analogWrite(PWM_Wert, LED_PIN);
}
Falls du einen nicht-linearen Zusammenhang hast, musst du anstelle des map() befehles eine andere Form der Umrechnung wählen.
Moin Gunther,die LED schaltet zwar an aber eigendlich sollte die Leuchtstärke variabel sein und das ständig.Hier ist noch mal die Bezeichnung vom Sensor: LM393 Lichtsensor Modul (analog + digital)
MfG
Crazydiver
Was für Werte bekommst du denn vom Lichtsensor?
Die Werte für HellMin und HellMax habe ich rein zufällig gewählt, um zu verdeutlichen, wie der Code funktioniert.
Das müsstest du erstmal ermittelt.
Hast du dir über Serial.print mal die Werte ausgeben lassen?
Das habe ich mit einem anderen Sketch schon gemacht.Die Werte sind fast gleich.
der Wert für HellMin ist 210 und für HellMax bei 730.
Wird denn die LED auch entsprechend mit mit PWM angesteuert?
Welcher Pin?
Wie genau wird die LED denn angesteuert?
die Backlight LEDs kann man oft nicht direkt ansteuern.
geht es denn mit einer normalen LED?
Leider nicht ich habe aber es schon mal mit einem Poti probiert den ich direkt an der LEDsteckbrücke angeschlossen habe.
wie sieht dein aktueller Sketch aus?
Leider nicht?
LEIDER NICHT?????
Ich habe dir vier Fragen gestellt, die du schnöde mit "leider nicht" beantwortest?
Sorry, ich versuche schon zu helfen, aber ich möchte auch ernst genommen werden.
Ein Minimum an Information ist unverzichtbar um Probleme zu lösen.
Moin Jurs, als erstes es ist eine analoge Datenausgabe vom Sensor.Zweitens es ist kein I2C Sensor.Drittens es ist der Sensor LM393 Lichtsensor Modul (analog + digital) bei dem der analoge Ausgang genutzt wird. Und viertens es sind folgende Werte von Minimum zum Maximun von 210 bis 730 im Monitor zu sehen.
MfG
Crazydiver
Moin Ardubu,hier ist der aktuelle Sketch.
#include <Wire.h> // I2C Umsetzer
#include <LiquidCrystal_I2C.h> //Display einbinden
LiquidCrystal_I2C lcd1(0x27, 16, 2); //Displays initalisieren
LiquidCrystal_I2C lcd(0x26, 20, 4);
const int LED1 = 13;
const int LED2 = 9;
const int schalterpin = 8;
const int potPin = A0;
const int HellMin = 200; // Lichteinfall, ab dem den minimale Display Helligkeit angesteuert wird
const int HellMax = 800;
int schalterPin = 8; // Signalpin 8 fuer Textumschaltung
int textumschalter = 0; // Signal Textumschaltung
void setup() {
lcd.backlight(); // beide Displaybeleuchtungen an
lcd1.backlight();
lcd.init(); // Displays loeschen
lcd1.init();
pinMode(LED1, OUTPUT);
pinMode(LED2, OUTPUT);
pinMode(schalterpin, INPUT);
}
void loop() {
int Hell = analogRead(A0); // Lichtsensor einlesen
Hell = constrain(Hell, HellMin, HellMax); // die Werte begrenzen auf die Schwellwerte
byte PWM_Wert = map(Hell, HellMin, HellMax, 0, 255); // helligkeit in Licht-PWM umrechnen.
analogWrite(PWM_Wert, LED2);
lcd.init(); // Displays loeschen
lcd1.init();
textumschalter = digitalRead(schalterPin);
if (textumschalter == LOW){
digitalWrite(LED1, LOW);
lcd.setCursor(6,0);
lcd.print("Vorsicht");
lcd.setCursor(3,1);
lcd.print("Ausnahmekonvoi");
lcd.setCursor(8,2);
lcd.print("Lu`s");
lcd.setCursor(4,3);
lcd.print("Spezialtrans");
lcd1.setCursor(4,0);
lcd1.print("Vorsicht");
lcd1.setCursor(1,1);
lcd1.print("Ausnahmekonvoi");
}
// Umschaltung zum englischen Text
else if (textumschalter == HIGH) {
digitalWrite(LED1, HIGH);
lcd.setCursor(5,0);
lcd.print("Attention");
lcd.setCursor(0,1);
lcd.print("Convoi Exceptionnel");
lcd.setCursor(8,2);
lcd.print("Lu`s");
lcd.setCursor(4,3);
lcd.print("Specialtrans");
lcd1.setCursor(0,0);
lcd1.print("Attention Convoi");
lcd1.setCursor(2,1);
lcd1.print("Exceptionnel");
}
}
Ich denke du verwechselst Jurs und Guntherb.
Lass dir mal den PWM_Wert im seriellen Monitor anzeigen.
Moin ardubu, das habe ich sonst hätte ich nicht beide Werte für Maximal und Minimal bekommen.
MfG
Crazydiver