mein Code liest ein Analogsignal ein und dieses will ich umrechnen. (siehe unten)
double sensorPin = A0; // select the input pin for the potentiometer
double sensorValue = 0; // variable to store the value coming from the sensor
int dimled = 8; // pin led dimmen
int a; // hilfsvariable berechnung
int b; // prozentualer wert von senorValue (100% = 50)
int Dauer;
void setup()
{
// declare the ledPin as an OUTPUT:
pinMode(dimled, OUTPUT);
}
void loop()
{
// read the value from the sensor:
sensorValue = analogRead(sensorPin);
// turn the ledPin on
sensorValue * 10 = a;
(100/50) * a = b; // prozent Helligkeit
(b/100) * 2 = Dauer;
in der letzten Zeile bekomme ich den Error: lvalue required as left operand of assignment
Weis jemand was ich falsch mache, oder nicht beachtet hatte?
Also hier noch einmal der Vollständige Code. Hatte vorhin nur einen Teil eingefügt.
double sensorPin = A0; // select the input pin for the potentiometer
double sensorValue = 0; // variable to store the value coming from the sensor
int dimled = 8; // pin led to dime
int a; // hilfsvariable berechnung
int b; // prozentualer wert von senorValue (100% = 50)
int Dauer;
void setup()
{
// declare the ledPin as an OUTPUT:
pinMode(dimled, OUTPUT);
}
void loop()
{
// read the value from the sensor:
sensorValue = analogRead(sensorPin);
// turn the ledPin on
sensorValue * 10 = a;
(100/50) * a = b; // prozent Helligkeit
(b/100) * 2 = Dauer;
digitalWrite(dimled, HIGH);
// stop the program for <sensorValue> milliseconds:
delay(Dauer);
// turn the ledPin off:
digitalWrite(dimled, LOW);
// stop the program for for <sensorValue> milliseconds:
delay(2-Dauer);
}
Jetzt wird alles super kompiliert.
Am Ende ist mein Ziel, dass eine LED in abhängigkeit vom Analogen Signal gedimmt wird. Das Signal wird über ein Potentiometer verändert. Also variiert das Signal von 0 V bis 5 V. Je nach Einstellung.
Leider leuchtet die LED beim Hochladen des Codes nur kurz auf und dann bleibt sie aus. Ist von der Code-Seite her alles korrekt?
double sensorPin = A0; // select the input pin for the potentiometer
double sensorValue = 0; // variable to store the value coming from the sensor
int dimled = 8; // pin led to dime
double a; // hilfsvariable berechnung
double b; // prozentualer wert von senorValue (100% = 50)
double Dauer;
void setup()
{
// declare the ledPin as an OUTPUT:
pinMode(dimled, OUTPUT);
}
void loop()
{
// read the value from the sensor:
sensorValue = analogRead(sensorPin);
// turn the ledPin on
a = sensorValue * 10;
b = (100/50) * a; // prozent Anteil Einschaltdauer in Periode von 2 ms
Dauer = (b/100) * 2; // einschaltdauer in ms
digitalWrite(dimled, HIGH);
// stop the program for <sensorValue> milliseconds:
delay(Dauer);
// turn the ledPin off:
digitalWrite(dimled, LOW);
// stop the program for for <sensorValue> milliseconds:
delay(2-Dauer);
}
titoardo:
Die Möglichkeit kenne ich auch.. Wollte es aber gerne so probieren um einen Lerneffekt zu haben.
Verschiedene Wege führen nach Rom und so.
.....
Und was hast du daraus gelernt ?
Das es so nicht geht ?
Wenn man in Deinem Programm ein paar Dinge ändert, kommt tatsächlich PWM raus. Die Zeitspanne beträgt 408 ms, weshalb eine LED für uns Menschen eher als blinkend wahrgenommen wird, Dimmen müßte schneller sein.
Also PWM ist es, aber Dimmen eher nicht.
const byte sensorPin = A0; // select the input pin for the potentiometer
unsigned int sensorValue; // variable to store the value coming from the sensor
const byte dimled = 8; // pin led to dime
unsigned int a; // hilfsvariable berechnung
unsigned int b; // prozentualer wert von senorValue (100% = 50)
unsigned int dauer;
void setup()
{
Serial.begin(9600);
// declare the ledPin as an OUTPUT:
pinMode(dimled, OUTPUT);
}
void loop()
{
// read the value from the sensor:
sensorValue = analogRead(sensorPin);
a = sensorValue * 10;
b = (100 / 50) * a; // prozent Helligkeit
dauer = (b / 100) * 2;
Serial.print("sensorValue: "); Serial.print(sensorValue);
Serial.print("\ta: "); Serial.print(a);
Serial.print("\tb: "); Serial.print(b);
Serial.print("\tdauer: "); Serial.print(dauer);
Serial.println();
digitalWrite(dimled, HIGH);
// stop the program for <sensorValue> milliseconds:
delay(dauer);
// turn the ledPin off:
digitalWrite(dimled, LOW);
// stop the program for for <sensorValue> milliseconds:
delay(1023 * 2 / 10 * 2 - dauer);
}
Mit delayMicroseconds kommst Du näher an Dein Ziel, nur Serial geht dann nicht mehr, weil zu langsam:
const byte sensorPin = A0; // select the input pin for the potentiometer
unsigned int sensorValue; // variable to store the value coming from the sensor
const byte dimled = 8; // pin led to dime
unsigned int a; // hilfsvariable berechnung
unsigned int b; // prozentualer wert von senorValue (100% = 50)
unsigned int dauer;
void setup()
{
// declare the ledPin as an OUTPUT:
pinMode(dimled, OUTPUT);
}
void loop()
{
// read the value from the sensor:
sensorValue = analogRead(sensorPin);
a = sensorValue * 10;
b = (100 / 50) * a; // prozent Helligkeit
dauer = (b / 100) * 2;
digitalWrite(dimled, HIGH);
// stop the program for <sensorValue> milliseconds:
delayMicroseconds(dauer);
// turn the ledPin off:
digitalWrite(dimled, LOW);
// stop the program for for <sensorValue> milliseconds:
delayMicroseconds(1023 * 2 / 10 * 2 - dauer);
}
Ob Deine Berechnungen zum Kommentar passen, habe ich mir nicht angesehen
titoardo:
Es scheint mir, dass die benötigte Frequenz nicht erreicht werden kann.
Richtig, der µC ist dafür zu langsam.
Weil die Entwickler das wußten, haben sie einigen Ausgängen im Zusammenspiel mit Timern die spezielle Möglichkeit für PWM mitgegeben. Mit analogWrite (analog ist irreführend) kannst Du an diesen Ausgängen ein PWM-Signal erzeugen.
